repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list |
|---|---|---|---|---|
Yu-Nie/Yolo-v2-pytorch
|
[
"da18482b0d53ef4a99c88bde599927408c819127"
] |
[
"train_coco.py"
] |
[
"\"\"\"\n@author: Viet Nguyen <nhviet1009@gmail.com>\n\"\"\"\nimport os\nimport argparse\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nfrom src.coco_dataset import COCODataset\nfrom src.utils import *\nfrom src.loss import YoloLoss\nfrom src.yolo_net import Yolo\nfrom tensorboardX import SummaryWriter\nimport shutil\n\n\ndef get_args():\n parser = argparse.ArgumentParser(\"You Only Look Once: Unified, Real-Time Object Detection\")\n parser.add_argument(\"--image_size\", type=int, default=448, help=\"The common width and height for all images\")\n parser.add_argument(\"--batch_size\", type=int, default=10, help=\"The number of images per batch\")\n parser.add_argument(\"--momentum\", type=float, default=0.9)\n parser.add_argument(\"--decay\", type=float, default=0.0005)\n parser.add_argument(\"--dropout\", type=float, default=0.5)\n parser.add_argument(\"--num_epoches\", type=int, default=160)\n parser.add_argument(\"--test_interval\", type=int, default=5, help=\"Number of epoches between testing phases\")\n parser.add_argument(\"--object_scale\", type=float, default=1.0)\n parser.add_argument(\"--noobject_scale\", type=float, default=0.5)\n parser.add_argument(\"--class_scale\", type=float, default=1.0)\n parser.add_argument(\"--coord_scale\", type=float, default=5.0)\n parser.add_argument(\"--reduction\", type=int, default=32)\n parser.add_argument(\"--es_min_delta\", type=float, default=0.0,\n help=\"Early stopping's parameter: minimum change loss to qualify as an improvement\")\n parser.add_argument(\"--es_patience\", type=int, default=0,\n help=\"Early stopping's parameter: number of epochs with no improvement after which training will be stopped. Set to 0 to disable this technique.\")\n parser.add_argument(\"--train_set\", type=str, default=\"train\")\n parser.add_argument(\"--test_set\", type=str, default=\"val\")\n parser.add_argument(\"--year\", type=str, default=\"2014\", help=\"The year of dataset (2014 or 2017)\")\n parser.add_argument(\"--data_path\", type=str, default=\"data/COCO\", help=\"the root folder of dataset\")\n parser.add_argument(\"--pre_trained_model_type\", type=str, choices=[\"model\", \"params\"], default=\"model\")\n parser.add_argument(\"--pre_trained_model_path\", type=str, default=\"trained_models/whole_model_trained_yolo_coco\")\n parser.add_argument(\"--log_path\", type=str, default=\"tensorboard/yolo_coco\")\n parser.add_argument(\"--saved_path\", type=str, default=\"trained_models\")\n\n args = parser.parse_args()\n return args\n\n\ndef train(opt):\n if torch.cuda.is_available():\n torch.cuda.manual_seed(123)\n else:\n torch.manual_seed(123)\n learning_rate_schedule = {\"0\": 1e-5, \"5\": 1e-4,\n \"80\": 1e-5, \"110\": 1e-6}\n training_params = {\"batch_size\": opt.batch_size,\n \"shuffle\": True,\n \"drop_last\": True,\n \"collate_fn\": custom_collate_fn}\n\n test_params = {\"batch_size\": opt.batch_size,\n \"shuffle\": False,\n \"drop_last\": False,\n \"collate_fn\": custom_collate_fn}\n\n training_set = COCODataset(opt.data_path, opt.year, opt.train_set, opt.image_size)\n training_generator = DataLoader(training_set, **training_params)\n\n test_set = COCODataset(opt.data_path, opt.year, opt.test_set, opt.image_size, is_training=False)\n test_generator = DataLoader(test_set, **test_params)\n\n '''\n if torch.cuda.is_available():\n if opt.pre_trained_model_type == \"model\":\n model = torch.load(opt.pre_trained_model_path)\n else:\n model = Yolo(training_set.num_classes)\n model.load_state_dict(torch.load(opt.pre_trained_model_path))\n else:\n if opt.pre_trained_model_type == \"model\":\n model = torch.load(opt.pre_trained_model_path, map_location=lambda storage, loc: storage)\n else:\n model = Yolo(training_set.num_classes)\n model.load_state_dict(torch.load(opt.pre_trained_model_path, map_location=lambda storage, loc: storage))\n '''\n model = Yolo(training_set.num_classes)\n # The following line will re-initialize weight for the last layer, which is useful\n # when you want to retrain the model based on my trained weights. if you uncomment it,\n # you will see the loss is already very small at the beginning.\n nn.init.normal_(list(model.modules())[-1].weight, 0, 0.01)\n log_path = os.path.join(opt.log_path, \"{}\".format(opt.year))\n if os.path.isdir(log_path):\n shutil.rmtree(log_path)\n os.makedirs(log_path)\n writer = SummaryWriter(log_path)\n if torch.cuda.is_available():\n writer.add_graph(model.cpu(), torch.rand(opt.batch_size, 3, opt.image_size, opt.image_size))\n model.cuda()\n else:\n writer.add_graph(model, torch.rand(opt.batch_size, 3, opt.image_size, opt.image_size))\n criterion = YoloLoss(training_set.num_classes, model.anchors, opt.reduction)\n optimizer = torch.optim.SGD(model.parameters(), lr=1e-5, momentum=opt.momentum, weight_decay=opt.decay)\n best_loss = 1e10\n best_epoch = 0\n model.train()\n num_iter_per_epoch = len(training_generator)\n for epoch in range(opt.num_epoches):\n if str(epoch) in learning_rate_schedule.keys():\n for param_group in optimizer.param_groups:\n param_group['lr'] = learning_rate_schedule[str(epoch)]\n for iter, batch in enumerate(training_generator):\n image, label = batch\n if torch.cuda.is_available():\n image = Variable(image.cuda(), requires_grad=True)\n else:\n image = Variable(image, requires_grad=True)\n optimizer.zero_grad()\n logits = model(image)\n loss, loss_coord, loss_conf, loss_cls = criterion(logits, label)\n loss.backward()\n optimizer.step()\n print(\"Epoch: {}/{}, Iteration: {}/{}, Lr: {}, Loss:{:.2f} (Coord:{:.2f} Conf:{:.2f} Cls:{:.2f})\".format(\n epoch + 1,\n opt.num_epoches,\n iter + 1,\n num_iter_per_epoch,\n optimizer.param_groups[0]['lr'],\n loss,\n loss_coord,\n loss_conf,\n loss_cls))\n writer.add_scalar('Train/Total_loss', loss, epoch * num_iter_per_epoch + iter)\n writer.add_scalar('Train/Coordination_loss', loss_coord, epoch * num_iter_per_epoch + iter)\n writer.add_scalar('Train/Confidence_loss', loss_conf, epoch * num_iter_per_epoch + iter)\n writer.add_scalar('Train/Class_loss', loss_cls, epoch * num_iter_per_epoch + iter)\n if epoch % opt.test_interval == 0:\n model.eval()\n loss_ls = []\n loss_coord_ls = []\n loss_conf_ls = []\n loss_cls_ls = []\n for te_iter, te_batch in enumerate(test_generator):\n te_image, te_label = te_batch\n num_sample = len(te_label)\n if torch.cuda.is_available():\n te_image = te_image.cuda()\n with torch.no_grad():\n te_logits = model(te_image)\n batch_loss, batch_loss_coord, batch_loss_conf, batch_loss_cls = criterion(te_logits, te_label)\n loss_ls.append(batch_loss * num_sample)\n loss_coord_ls.append(batch_loss_coord * num_sample)\n loss_conf_ls.append(batch_loss_conf * num_sample)\n loss_cls_ls.append(batch_loss_cls * num_sample)\n te_loss = sum(loss_ls) / test_set.__len__()\n te_coord_loss = sum(loss_coord_ls) / test_set.__len__()\n te_conf_loss = sum(loss_conf_ls) / test_set.__len__()\n te_cls_loss = sum(loss_cls_ls) / test_set.__len__()\n print(\"Epoch: {}/{}, Lr: {}, Loss:{:.2f} (Coord:{:.2f} Conf:{:.2f} Cls:{:.2f})\".format(\n epoch + 1,\n opt.num_epoches,\n optimizer.param_groups[0]['lr'],\n te_loss,\n te_coord_loss,\n te_conf_loss,\n te_cls_loss))\n writer.add_scalar('Test/Total_loss', te_loss, epoch)\n writer.add_scalar('Test/Coordination_loss', te_coord_loss, epoch)\n writer.add_scalar('Test/Confidence_loss', te_conf_loss, epoch)\n writer.add_scalar('Test/Class_loss', te_cls_loss, epoch)\n model.train()\n if te_loss + opt.es_min_delta < best_loss:\n best_loss = te_loss\n best_epoch = epoch\n # torch.save(model, opt.saved_path + os.sep + \"trained_yolo_coco\")\n torch.save(model.state_dict(), opt.saved_path + os.sep + \"only_params_trained_yolo_coco\")\n torch.save(model, opt.saved_path + os.sep + \"whole_model_trained_yolo_coco\")\n\n # Early stopping\n if epoch - best_epoch > opt.es_patience > 0:\n print(\"Stop training at epoch {}. The lowest loss achieved is {}\".format(epoch, te_loss))\n break\n writer.export_scalars_to_json(log_path + os.sep + \"all_logs.json\")\n writer.close()\n\n\nif __name__ == \"__main__\":\n opt = get_args()\n train(opt)\n"
] |
[
[
"torch.utils.data.DataLoader"
]
] |
yuanqidu/IDGL
|
[
"64d2d73289ca0f6dcab966062d4cb15844236b37",
"64d2d73289ca0f6dcab966062d4cb15844236b37"
] |
[
"src/core/model.py",
"src/core/layers/scalable_graphlearn.py"
] |
[
"import os\nimport random\nimport numpy as np\nfrom collections import Counter\nfrom sklearn.metrics import r2_score\n\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch.optim.lr_scheduler import ReduceLROnPlateau\nimport torch.nn.functional as F\n\nfrom .models.graph_clf import GraphClf\nfrom .models.text_graph import TextGraphRegression, TextGraphClf\nfrom .utils.text_data.vocab_utils import VocabModel\nfrom .utils import constants as Constants\nfrom .utils.generic_utils import to_cuda, create_mask\nfrom .utils.constants import INF\nfrom .utils.radam import RAdam\n\n\nclass Model(object):\n \"\"\"High level model that handles intializing the underlying network\n architecture, saving, updating examples, and predicting examples.\n \"\"\"\n def __init__(self, config, train_set=None):\n self.config = config\n if self.config['model_name'] == 'GraphClf':\n self.net_module = GraphClf\n elif self.config['model_name'] == 'TextGraphRegression':\n self.net_module = TextGraphRegression\n elif self.config['model_name'] == 'TextGraphClf':\n self.net_module = TextGraphClf\n else:\n raise RuntimeError('Unknown model_name: {}'.format(self.config['model_name']))\n print('[ Running {} model ]'.format(self.config['model_name']))\n\n if config['data_type'] == 'text':\n saved_vocab_file = os.path.join(config['data_dir'], '{}_seed{}.vocab'.format(config['dataset_name'], config.get('data_seed', 1234)))\n self.vocab_model = VocabModel.build(saved_vocab_file, train_set, self.config)\n\n if config['task_type'] == 'regression':\n assert config['out_predictions']\n self.criterion = F.mse_loss\n self.score_func = r2_score\n self.metric_name = 'r2'\n elif config['task_type'] == 'classification':\n self.criterion = F.nll_loss\n self.score_func = accuracy\n self.metric_name = 'acc'\n else:\n self.criterion = F.nll_loss\n self.score_func = None\n self.metric_name = None\n\n\n\n if self.config['pretrained']:\n self.init_saved_network(self.config['pretrained'])\n else:\n # Building network.\n self._init_new_network()\n\n num_params = 0\n for name, p in self.network.named_parameters():\n print('{}: {}'.format(name, str(p.size())))\n num_params += p.numel()\n\n print('#Parameters = {}\\n'.format(num_params))\n self._init_optimizer()\n\n\n def init_saved_network(self, saved_dir):\n _ARGUMENTS = ['word_embed_dim', 'hidden_size', 'f_qem', 'f_pos', 'f_ner',\n 'word_dropout', 'rnn_dropout',\n 'ctx_graph_hops', 'ctx_graph_topk',\n 'score_unk_threshold', 'score_yes_threshold',\n 'score_no_threshold']\n\n # Load all saved fields.\n fname = os.path.join(saved_dir, Constants._SAVED_WEIGHTS_FILE)\n print('[ Loading saved model %s ]' % fname)\n saved_params = torch.load(fname, map_location=lambda storage, loc: storage)\n self.state_dict = saved_params['state_dict']\n # for k in _ARGUMENTS:\n # if saved_params['config'][k] != self.config[k]:\n # print('Overwrite {}: {} -> {}'.format(k, self.config[k], saved_params['config'][k]))\n # self.config[k] = saved_params['config'][k]\n\n if self.config['data_type'] == 'text':\n w_embedding = self._init_embedding(len(self.vocab_model.word_vocab), self.config['word_embed_dim'])\n self.network = self.net_module(self.config, w_embedding, self.vocab_model.word_vocab)\n else:\n self.network = self.net_module(self.config)\n\n # Merge the arguments\n if self.state_dict:\n merged_state_dict = self.network.state_dict()\n for k, v in self.state_dict['network'].items():\n if k in merged_state_dict:\n merged_state_dict[k] = v\n self.network.load_state_dict(merged_state_dict)\n\n def _init_new_network(self):\n if self.config['data_type'] == 'text':\n w_embedding = self._init_embedding(len(self.vocab_model.word_vocab), self.config['word_embed_dim'],\n pretrained_vecs=self.vocab_model.word_vocab.embeddings)\n self.network = self.net_module(self.config, w_embedding, self.vocab_model.word_vocab)\n else:\n self.network = self.net_module(self.config)\n\n def _init_optimizer(self):\n parameters = [p for p in self.network.parameters() if p.requires_grad]\n if self.config['optimizer'] == 'sgd':\n self.optimizer = optim.SGD(parameters, self.config['learning_rate'],\n momentum=self.config['momentum'],\n weight_decay=self.config['weight_decay'])\n elif self.config['optimizer'] == 'adam':\n self.optimizer = optim.Adam(parameters, lr=self.config['learning_rate'], weight_decay=self.config['weight_decay'])\n elif self.config['optimizer'] == 'adamax':\n self.optimizer = optim.Adamax(parameters, lr=self.config['learning_rate'])\n elif self.config['optimizer'] == 'radam':\n self.optimizer = RAdam(parameters, lr=self.config['learning_rate'], weight_decay=self.config['weight_decay'])\n else:\n raise RuntimeError('Unsupported optimizer: %s' % self.config['optimizer'])\n self.scheduler = ReduceLROnPlateau(self.optimizer, mode='max', factor=self.config['lr_reduce_factor'], \\\n patience=self.config['lr_patience'], verbose=True)\n\n def _init_embedding(self, vocab_size, embed_size, pretrained_vecs=None):\n \"\"\"Initializes the embeddings\n \"\"\"\n return nn.Embedding(vocab_size, embed_size, padding_idx=0,\n _weight=torch.from_numpy(pretrained_vecs).float()\n if pretrained_vecs is not None else None)\n\n def save(self, dirname):\n params = {\n 'state_dict': {\n 'network': self.network.state_dict(),\n },\n 'config': self.config,\n 'dir': dirname,\n }\n try:\n torch.save(params, os.path.join(dirname, Constants._SAVED_WEIGHTS_FILE))\n except BaseException:\n print('[ WARN: Saving failed... continuing anyway. ]')\n\n\n def clip_grad(self):\n # Clip gradients\n if self.config['grad_clipping']:\n parameters = [p for p in self.network.parameters() if p.requires_grad]\n torch.nn.utils.clip_grad_norm_(parameters, self.config['grad_clipping'])\n\ndef train_batch(batch, network, vocab, criterion, forcing_ratio, rl_ratio, config, wmd=None):\n network.train(True)\n\n with torch.set_grad_enabled(True):\n ext_vocab_size = batch['oov_dict'].ext_vocab_size if batch['oov_dict'] else None\n\n network_out = network(batch, batch['targets'], criterion,\n forcing_ratio=forcing_ratio, partial_forcing=config['partial_forcing'], \\\n sample=config['sample'], ext_vocab_size=ext_vocab_size, \\\n include_cover_loss=config['show_cover_loss'])\n\n if rl_ratio > 0:\n batch_size = batch['context'].shape[0]\n sample_out = network(batch, saved_out=network_out, criterion=criterion, \\\n criterion_reduction=False, criterion_nll_only=True, \\\n sample=True, ext_vocab_size=ext_vocab_size)\n baseline_out = network(batch, saved_out=network_out, visualize=False, \\\n ext_vocab_size=ext_vocab_size)\n\n sample_out_decoded = sample_out.decoded_tokens.transpose(0, 1)\n baseline_out_decoded = baseline_out.decoded_tokens.transpose(0, 1)\n\n neg_reward = []\n for i in range(batch_size):\n scores = eval_batch_output([batch['target_src'][i]], vocab, batch['oov_dict'],\n [sample_out_decoded[i]], [baseline_out_decoded[i]])\n\n greedy_score = scores[1][config['rl_reward_metric']]\n reward_ = scores[0][config['rl_reward_metric']] - greedy_score\n\n if config['rl_wmd_ratio'] > 0:\n # Add word mover's distance\n sample_seq = batch_decoded_index2word([sample_out_decoded[i]], vocab, batch['oov_dict'])[0]\n greedy_seq = batch_decoded_index2word([baseline_out_decoded[i]], vocab, batch['oov_dict'])[0]\n\n sample_wmd = -wmd.distance(sample_seq, batch['target_src'][i]) / max(len(sample_seq.split()), 1)\n greedy_wmd = -wmd.distance(greedy_seq, batch['target_src'][i]) / max(len(greedy_seq.split()), 1)\n wmd_reward_ = sample_wmd - greedy_wmd\n wmd_reward_ = max(min(wmd_reward_, config['max_wmd_reward']), -config['max_wmd_reward'])\n reward_ += config['rl_wmd_ratio'] * wmd_reward_\n\n neg_reward.append(reward_)\n neg_reward = to_cuda(torch.Tensor(neg_reward), network.device)\n\n\n # if sample > baseline, the reward is positive (i.e. good exploration), rl_loss is negative\n rl_loss = torch.sum(neg_reward * sample_out.loss) / batch_size\n rl_loss_value = torch.sum(neg_reward * sample_out.loss_value).item() / batch_size\n loss = (1 - rl_ratio) * network_out.loss + rl_ratio * rl_loss\n loss_value = (1 - rl_ratio) * network_out.loss_value + rl_ratio * rl_loss_value\n\n metrics = eval_batch_output(batch['target_src'], vocab, \\\n batch['oov_dict'], baseline_out.decoded_tokens)[0]\n\n else:\n loss = network_out.loss\n loss_value = network_out.loss_value\n metrics = eval_batch_output(batch['target_src'], vocab, \\\n batch['oov_dict'], network_out.decoded_tokens)[0]\n\n return loss, loss_value, metrics\n\ndef accuracy(labels, output):\n preds = output.max(1)[1].type_as(labels)\n correct = preds.eq(labels).double()\n correct = correct.sum().item()\n return correct / len(labels)\n",
"import math\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom ..utils.generic_utils import to_cuda, normalize_adj\nfrom ..utils.constants import VERY_SMALL_NUMBER, INF\n\n\ndef compute_normalized_laplacian(adj):\n rowsum = torch.sum(adj, -1)\n d_inv_sqrt = torch.pow(rowsum, -0.5)\n d_inv_sqrt[torch.isinf(d_inv_sqrt)] = 0.\n d_mat_inv_sqrt = torch.diagflat(d_inv_sqrt)\n L_norm = torch.mm(torch.mm(d_mat_inv_sqrt, adj), d_mat_inv_sqrt)\n return L_norm\n\n\nclass AnchorGraphLearner(nn.Module):\n def __init__(self, input_size, hidden_size, topk=None, epsilon=None, num_pers=16, metric_type='attention', device=None):\n super(AnchorGraphLearner, self).__init__()\n self.device = device\n self.topk = topk\n self.epsilon = epsilon\n self.metric_type = metric_type\n if metric_type == 'attention':\n self.linear_sims = nn.ModuleList([nn.Linear(input_size, hidden_size, bias=False) for _ in range(num_pers)])\n print('[ Multi-perspective {} AnchorGraphLearner: {} ]'.format(metric_type, num_pers))\n\n elif metric_type == 'weighted_cosine':\n self.weight_tensor = torch.Tensor(num_pers, input_size)\n self.weight_tensor = nn.Parameter(nn.init.xavier_uniform_(self.weight_tensor))\n print('[ Multi-perspective {} AnchorGraphLearner: {} ]'.format(metric_type, num_pers))\n\n\n elif metric_type == 'gat_attention':\n self.linear_sims1 = nn.ModuleList([nn.Linear(input_size, 1, bias=False) for _ in range(num_pers)])\n self.linear_sims2 = nn.ModuleList([nn.Linear(input_size, 1, bias=False) for _ in range(num_pers)])\n\n self.leakyrelu = nn.LeakyReLU(0.2)\n\n print('[ GAT_Attention AnchorGraphLearner]')\n\n elif metric_type == 'kernel':\n self.precision_inv_dis = nn.Parameter(torch.Tensor(1, 1))\n self.precision_inv_dis.data.uniform_(0, 1.0)\n self.weight = nn.Parameter(nn.init.xavier_uniform_(torch.Tensor(input_size, hidden_size)))\n elif metric_type == 'transformer':\n self.linear_sim1 = nn.Linear(input_size, hidden_size, bias=False)\n self.linear_sim2 = nn.Linear(input_size, hidden_size, bias=False)\n\n\n elif metric_type == 'cosine':\n pass\n\n else:\n raise ValueError('Unknown metric_type: {}'.format(metric_type))\n\n print('[ Graph Learner metric type: {} ]'.format(metric_type))\n\n def forward(self, context, anchors, ctx_mask=None, anchor_mask=None):\n \"\"\"\n Parameters\n :context, (batch_size, ctx_size, dim)\n :ctx_mask, (batch_size, ctx_size)\n\n Returns\n :attention, (batch_size, ctx_size, ctx_size)\n \"\"\"\n if self.metric_type == 'attention':\n attention = 0\n for _ in range(len(self.linear_sims)):\n context_fc = torch.relu(self.linear_sims[_](context))\n attention += torch.matmul(context_fc, context_fc.transpose(-1, -2))\n\n attention /= len(self.linear_sims)\n markoff_value = -INF\n\n elif self.metric_type == 'weighted_cosine':\n expand_weight_tensor = self.weight_tensor.unsqueeze(1)\n if len(context.shape) == 3:\n expand_weight_tensor = expand_weight_tensor.unsqueeze(1)\n\n context_fc = context.unsqueeze(0) * expand_weight_tensor\n context_norm = F.normalize(context_fc, p=2, dim=-1)\n\n anchors_fc = anchors.unsqueeze(0) * expand_weight_tensor\n anchors_norm = F.normalize(anchors_fc, p=2, dim=-1)\n\n attention = torch.matmul(context_norm, anchors_norm.transpose(-1, -2)).mean(0)\n markoff_value = 0\n\n\n elif self.metric_type == 'transformer':\n Q = self.linear_sim1(context)\n attention = torch.matmul(Q, Q.transpose(-1, -2)) / math.sqrt(Q.shape[-1])\n markoff_value = -INF\n\n\n elif self.metric_type == 'gat_attention':\n attention = []\n for _ in range(len(self.linear_sims1)):\n a_input1 = self.linear_sims1[_](context)\n a_input2 = self.linear_sims2[_](context)\n attention.append(self.leakyrelu(a_input1 + a_input2.transpose(-1, -2)))\n\n attention = torch.mean(torch.stack(attention, 0), 0)\n markoff_value = -INF\n\n\n elif self.metric_type == 'kernel':\n dist_weight = torch.mm(self.weight, self.weight.transpose(-1, -2))\n attention = self.compute_distance_mat(context, dist_weight)\n attention = torch.exp(-0.5 * attention * (self.precision_inv_dis**2))\n\n markoff_value = 0\n\n elif self.metric_type == 'cosine':\n context_norm = context.div(torch.norm(context, p=2, dim=-1, keepdim=True))\n attention = torch.mm(context_norm, context_norm.transpose(-1, -2)).detach()\n markoff_value = 0\n\n\n if ctx_mask is not None:\n attention = attention.masked_fill_(1 - ctx_mask.byte().unsqueeze(-1), markoff_value)\n\n if anchor_mask is not None:\n attention = attention.masked_fill_(1 - anchor_mask.byte().unsqueeze(-2), markoff_value)\n\n if self.epsilon is not None:\n attention = self.build_epsilon_neighbourhood(attention, self.epsilon, markoff_value)\n\n if self.topk is not None:\n attention = self.build_knn_neighbourhood(attention, self.topk, markoff_value)\n\n return attention\n\n def build_knn_neighbourhood(self, attention, topk, markoff_value):\n topk = min(topk, attention.size(-1))\n knn_val, knn_ind = torch.topk(attention, topk, dim=-1)\n weighted_adjacency_matrix = to_cuda((markoff_value * torch.ones_like(attention)).scatter_(-1, knn_ind, knn_val), self.device)\n return weighted_adjacency_matrix\n\n def build_epsilon_neighbourhood(self, attention, epsilon, markoff_value):\n mask = (attention > epsilon).detach().float()\n weighted_adjacency_matrix = attention * mask + markoff_value * (1 - mask)\n return weighted_adjacency_matrix\n\n def compute_distance_mat(self, X, weight=None):\n if weight is not None:\n trans_X = torch.mm(X, weight)\n else:\n trans_X = X\n norm = torch.sum(trans_X * X, dim=-1)\n dists = -2 * torch.matmul(trans_X, X.transpose(-1, -2)) + norm.unsqueeze(0) + norm.unsqueeze(1)\n return dists\n\n\ndef get_binarized_kneighbors_graph(features, topk, mask=None, device=None):\n assert features.requires_grad is False\n # Compute cosine similarity matrix\n features_norm = features.div(torch.norm(features, p=2, dim=-1, keepdim=True))\n attention = torch.matmul(features_norm, features_norm.transpose(-1, -2))\n\n if mask is not None:\n attention = attention.masked_fill_(1 - mask.byte().unsqueeze(1), 0)\n attention = attention.masked_fill_(1 - mask.byte().unsqueeze(-1), 0)\n\n # Extract and Binarize kNN-graph\n topk = min(topk, attention.size(-1))\n _, knn_ind = torch.topk(attention, topk, dim=-1)\n adj = to_cuda(torch.zeros_like(attention).scatter_(-1, knn_ind, 1), device)\n return adj\n"
] |
[
[
"torch.nn.utils.clip_grad_norm_",
"torch.optim.SGD",
"torch.optim.Adam",
"torch.from_numpy",
"torch.optim.Adamax",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"torch.load",
"torch.Tensor",
"torch.set_grad_enabled",
"torch.sum"
],
[
"torch.nn.Linear",
"torch.nn.functional.normalize",
"torch.diagflat",
"torch.stack",
"torch.norm",
"torch.nn.LeakyReLU",
"torch.nn.init.xavier_uniform_",
"torch.pow",
"torch.mm",
"torch.sum",
"torch.isinf",
"torch.ones_like",
"torch.zeros_like",
"torch.Tensor",
"torch.exp",
"torch.topk"
]
] |
mylovage/czsc
|
[
"21c68c8451e951fd8f3c242c4c4f52dac5cb6283"
] |
[
"test/test_ta.py"
] |
[
"# coding: utf-8\nimport os\nimport pandas as pd\nimport numpy as np\nimport czsc\n\ncur_path = os.path.split(os.path.realpath(__file__))[0]\nfile_kline = os.path.join(cur_path, \"data/000001.SH_D.csv\")\nkline = pd.read_csv(file_kline, encoding=\"utf-8\")\nkline.loc[:, \"dt\"] = pd.to_datetime(kline.dt)\nbars = kline.to_dict(\"records\")\nclose = np.array([x['close'] for x in bars], dtype=np.double)\n\n\ndef test_sma():\n ma5 = czsc.SMA(close, 5)\n assert len(ma5) == len(close)\n assert round(ma5[-1], 2) == 3362.53\n assert round(ma5[-2], 2) == 3410.62\n\n\ndef test_macd():\n diff, dea, macd = czsc.MACD(close)\n\n assert len(diff) == len(dea) == len(macd) == len(close)\n assert round(macd[-1], 2) == 13.35\n assert round(macd[-5], 2) == 88.0\n\n assert round(diff[-1], 2) == 117.3\n assert round(diff[-5], 2) == 127.51\n\n assert round(dea[-1], 2) == 110.62\n assert round(dea[-5], 2) == 83.51\n\n\ndef test_jdk():\n high = np.array([x['high'] for x in bars], dtype=np.double)\n low = np.array([x['low'] for x in bars], dtype=np.double)\n k, d, j = czsc.KDJ(close, high, low)\n\n assert round(k[-1], 2) == 59.94\n assert round(d[-1], 2) == 80.47\n assert round(j[-1], 2) == 18.87\n"
] |
[
[
"pandas.to_datetime",
"numpy.array",
"pandas.read_csv"
]
] |
netanelbarel/improvedCvat
|
[
"ff2894d3b3757a5e080d3130d6875cfd14201bf5"
] |
[
"cvat/apps/engine/task.py"
] |
[
"# Copyright (C) 2018 Intel Corporation\r\n#\r\n# SPDX-License-Identifier: MIT\r\n\r\nimport os\r\nimport sys\r\nimport rq\r\nimport shlex\r\nimport shutil\r\nimport tempfile\r\nimport requests\r\nimport re\r\nimport xml.etree.ElementTree as ET\r\nfrom threading import Thread\r\nfrom io import BytesIO\r\nfrom PIL import Image\r\nfrom traceback import print_exception\r\nfrom ast import literal_eval\r\nfrom .handle_file_s3 import copyFileToOSByThread, deleteFolder, getFileUrl, copyFileToOS, uploadFile, downloadFile, getBucketConnection\r\nfrom .segmentation import process_watershed\r\n\r\nimport numpy as np\r\nimport urllib\r\nimport ssl\r\nfrom imutils.video import FPS\r\nimport argparse\r\nimport imutils\r\nimport cv2\r\nimport threading\r\nimport time\r\nimport json\r\nimport errno\r\n\r\nimport skvideo.io\r\n\r\nimport mimetypes\r\n_SCRIPT_DIR = os.path.realpath(os.path.dirname(__file__))\r\n_MEDIA_MIMETYPES_FILE = os.path.join(_SCRIPT_DIR, \"media.mimetypes\")\r\nmimetypes.init(files=[_MEDIA_MIMETYPES_FILE])\r\n\r\nfrom cvat.apps.engine.models import StatusChoice\r\nfrom cvat.apps.engine import formatter\r\n\r\nimport django_rq\r\nfrom django.forms.models import model_to_dict\r\nfrom django.conf import settings\r\nfrom django.core import serializers\r\nfrom django.db import transaction\r\nfrom django.db.models import Max\r\nfrom ffmpy import FFmpeg\r\nfrom pyunpack import Archive\r\nfrom distutils.dir_util import copy_tree\r\nfrom collections import OrderedDict\r\nfrom django.contrib.auth.models import User\r\n\r\nfrom . import models\r\nfrom .log import slogger\r\n\r\n############################# Global Variables\r\nTRACKER_THREADS = {}\r\n\r\n############################# Low Level server API\r\n\r\n@transaction.atomic\r\ndef create_empty(params):\r\n \"\"\"Create empty directory structure for a new task, add it to DB.\"\"\"\r\n\r\n db_task = models.Task()\r\n\r\n db_task.name = params['task_name']\r\n db_task.bug_tracker = params['bug_tracker_link']\r\n db_task.path = \"\"\r\n db_task.size = 0\r\n db_task.owner = params['owner']\r\n db_task.project = models.Projects.objects.get(pk=params['project'])\r\n db_task.assignee = User.objects.get(pk=params['assignee'])\r\n db_task.save()\r\n task_path = os.path.join(settings.DATA_ROOT, str(db_task.id))\r\n db_task.set_task_dirname(task_path)\r\n\r\n task_path = db_task.get_task_dirname()\r\n if os.path.isdir(task_path):\r\n shutil.rmtree(task_path)\r\n os.mkdir(task_path)\r\n\r\n upload_dir = db_task.get_upload_dirname()\r\n os.makedirs(upload_dir)\r\n output_dir = db_task.get_data_dirname()\r\n os.makedirs(output_dir)\r\n\r\n return db_task\r\n\r\ndef create(tid, params):\r\n \"\"\"Schedule the task\"\"\"\r\n q = django_rq.get_queue('default')\r\n q.enqueue_call(func=_create_thread, args=(tid, params),\r\n job_id=\"task.create/{}\".format(tid))\r\n\r\ndef check(tid):\r\n \"\"\"Check status of the scheduled task\"\"\"\r\n response = {}\r\n queue = django_rq.get_queue('default')\r\n job = queue.fetch_job(\"task.create/{}\".format(tid))\r\n if job is None:\r\n response = {\"state\": \"unknown\"}\r\n elif job.is_failed:\r\n response = {\"state\": \"error\", \"stderr\": \"Could not create the task. \" + job.exc_info }\r\n elif job.is_finished:\r\n destFile = r'/home/django/data/' + str(tid) + r'/data/xml/annotations.txt'\r\n if os.path.exists(destFile):\r\n with open(destFile, 'r') as f:\r\n fileData = f.read()\r\n response = {\"state\": \"created\", \"annotationFile\" : fileData, \"tid\" : tid}\r\n else:\r\n response = {\"state\": \"created\"}\r\n else:\r\n response = {\"state\": \"started\"}\r\n\r\n if 'status' in job.meta:\r\n response['status'] = job.meta['status']\r\n\r\n return response\r\n\r\n@transaction.atomic\r\ndef delete(tid):\r\n \"\"\"Delete the task\"\"\"\r\n db_task = models.Task.objects.select_for_update().get(pk=tid)\r\n if db_task:\r\n db_task.delete()\r\n shutil.rmtree(db_task.get_task_dirname(), ignore_errors=True)\r\n threads = deleteFolder(db_task.get_task_dirname())\r\n\r\n for t in threads:\r\n t.join()\r\n else:\r\n raise Exception(\"The task doesn't exist\")\r\n\r\n@transaction.atomic\r\ndef update(tid, labels, score, assignee):\r\n \"\"\"Update labels for the task\"\"\"\r\n\r\n db_task = models.Task.objects.select_for_update().get(pk=tid)\r\n db_labels = list(db_task.label_set.prefetch_related('attributespec_set').all())\r\n\r\n if (labels):\r\n new_labels = _parse_labels(labels)\r\n old_labels = _parse_db_labels(db_labels)\r\n\r\n for label_name in new_labels:\r\n if label_name in old_labels:\r\n db_label = [l for l in db_labels if l.name == label_name][0]\r\n for attr_name in new_labels[label_name]:\r\n if attr_name in old_labels[label_name]:\r\n db_attr = [attr for attr in db_label.attributespec_set.all()\r\n if attr.get_name() == attr_name][0]\r\n new_attr = new_labels[label_name][attr_name]\r\n old_attr = old_labels[label_name][attr_name]\r\n if new_attr['prefix'] != old_attr['prefix']:\r\n raise Exception(\"new_attr['prefix'] != old_attr['prefix']\")\r\n if new_attr['type'] != old_attr['type']:\r\n raise Exception(\"new_attr['type'] != old_attr['type']\")\r\n if set(old_attr['values']) - set(new_attr['values']):\r\n raise Exception(\"set(old_attr['values']) - set(new_attr['values'])\")\r\n\r\n db_attr.text = \"{}{}={}:{}\".format(new_attr['prefix'],\r\n new_attr['type'], attr_name, \",\".join(new_attr['values']))\r\n db_attr.save()\r\n else:\r\n db_attr = models.AttributeSpec()\r\n attr = new_labels[label_name][attr_name]\r\n db_attr.text = \"{}{}={}:{}\".format(attr['prefix'],\r\n attr['type'], attr_name, \",\".join(attr['values']))\r\n db_attr.label = db_label\r\n db_attr.save()\r\n else:\r\n db_label = models.Label()\r\n db_label.name = label_name\r\n db_label.task = db_task\r\n db_label.save()\r\n for attr_name in new_labels[label_name]:\r\n db_attr = models.AttributeSpec()\r\n attr = new_labels[label_name][attr_name]\r\n db_attr.text = \"{}{}={}:{}\".format(attr['prefix'],\r\n attr['type'], attr_name, \",\".join(attr['values']))\r\n db_attr.label = db_label\r\n db_attr.save()\r\n\r\n db_task.assignee = User.objects.get(pk=assignee)\r\n # If score sent from the client is -1 it means there is no score because the project has_score attribute is set to true.\r\n if (score != -1): \r\n db_task.score = score\r\n db_task.save()\r\n\r\n@transaction.atomic\r\ndef updateProperties(tid, properties):\r\n db_task = models.Task.objects.select_for_update().get(pk=tid)\r\n\r\n newFrameProperties = _parse_frameproperties(properties)\r\n\r\n for frameprop in newFrameProperties:\r\n db_taskframespec = models.TaskFrameSpec()\r\n db_taskframespec.task = db_task\r\n\r\n db_framepropvals = models.FrameProperties.objects.get(prop=frameprop[0], value=frameprop[1], project__pk=db_task.project.pk)\r\n db_taskframespec.propVal = db_framepropvals\r\n if (models.TaskFrameSpec.objects.filter(task__id=db_task.id, propVal__id=db_framepropvals.id).count() == 0):\r\n db_taskframespec.save()\r\n\r\ndef get_frame_path(tid, frame):\r\n \"\"\"Read corresponding frame for the task\"\"\"\r\n db_task = models.Task.objects.get(pk=tid)\r\n path = _get_frame_path(frame, db_task.get_data_dirname())\r\n\r\n return path\r\n\r\ndef get_frame_watershed_path(tid, frame):\r\n \"\"\"Read corresponding frame for the task\"\"\"\r\n db_task = models.Task.objects.get(pk=tid)\r\n path = _get_frame_watershed_path(frame, db_task.get_data_dirname())\r\n\r\n return path\r\n\r\ndef get(tid):\r\n \"\"\"Get the task as dictionary of attributes\"\"\"\r\n db_task = models.Task.objects.get(pk=tid)\r\n if db_task:\r\n db_labels = db_task.label_set.prefetch_related('attributespec_set').order_by('-pk').all()\r\n im_meta_data = get_image_meta_cache(db_task)\r\n attributes = {}\r\n for db_label in db_labels:\r\n attributes[db_label.id] = {}\r\n for db_attrspec in db_label.attributespec_set.all():\r\n attributes[db_label.id][db_attrspec.id] = db_attrspec.text\r\n db_segments = list(db_task.segment_set.prefetch_related('job_set').all())\r\n segment_length = max(db_segments[0].stop_frame - db_segments[0].start_frame + 1, 1)\r\n job_indexes = []\r\n for segment in db_segments:\r\n db_job = segment.job_set.first()\r\n job_indexes.append({\r\n \"job_id\": db_job.id,\r\n \"max_shape_id\": db_job.max_shape_id,\r\n })\r\n\r\n labels_colors = models.LabelDetails.objects.filter(labelType__label__in=[db_label.name for db_label in db_labels])\r\n\r\n response = {\r\n \"status\": db_task.status,\r\n \"spec\": {\r\n \"labels\": OrderedDict((db_label.id, db_label.name) for db_label in db_labels),\r\n \"attributes\": attributes,\r\n \"segmentation\": {label_color.labelType.label: {\"color\": label_color.color, \"label_type_id\": label_color.labelType.id} for label_color in labels_colors}\r\n },\r\n \"size\": db_task.size,\r\n \"taskid\": db_task.id,\r\n \"name\": db_task.name,\r\n \"mode\": db_task.mode,\r\n \"segment_length\": segment_length,\r\n \"jobs\": job_indexes,\r\n \"overlap\": db_task.overlap,\r\n \"z_orded\": db_task.z_order,\r\n \"flipped\": db_task.flipped,\r\n \"score\": db_task.score,\r\n \"image_meta_data\": im_meta_data,\r\n }\r\n else:\r\n raise Exception(\"Cannot find the task: {}\".format(tid))\r\n\r\n return response\r\n\r\n\r\n@transaction.atomic\r\ndef save_job_status(jid, status, user):\r\n db_job = models.Job.objects.select_related(\"segment__task\").select_for_update().get(pk = jid)\r\n db_task = db_job.segment.task\r\n status = StatusChoice(status)\r\n\r\n slogger.job[jid].info('changing job status from {} to {} by an user {}'.format(db_job.status, str(status), user))\r\n\r\n db_job.status = status.value\r\n db_job.save()\r\n db_segments = list(db_task.segment_set.prefetch_related('job_set').all())\r\n db_jobs = [db_segment.job_set.first() for db_segment in db_segments]\r\n\r\n if len(list(filter(lambda x: StatusChoice(x.status) == StatusChoice.ANNOTATION, db_jobs))) > 0:\r\n db_task.status = StatusChoice.ANNOTATION\r\n elif len(list(filter(lambda x: StatusChoice(x.status) == StatusChoice.VALIDATION, db_jobs))) > 0:\r\n db_task.status = StatusChoice.VALIDATION\r\n else:\r\n db_task.status = StatusChoice.COMPLETED\r\n\r\n db_task.save()\r\n\r\nclass CSRTTrackerThread(threading.Thread):\r\n def __init__(self, data, base_dir, results):\r\n threading.Thread.__init__(self)\r\n self.data = data\r\n self.base_dir = base_dir\r\n self.results = results\r\n self._stop_event = False\r\n def stop(self):\r\n self._stop_event = True\r\n def stopped(self):\r\n return self._stop_event\r\n def run(self):\r\n def _frame_path(frame, base_dir):\r\n d1 = str(frame // 10000)\r\n d2 = str(frame // 100)\r\n path = os.path.join(d1, d2, str(frame) + '.jpg')\r\n if base_dir:\r\n path = os.path.join(base_dir, path)\r\n\r\n return path\r\n\r\n def _get_frame(currentFrame, base_dir):\r\n # Download the requested frame\r\n frame_path = _frame_path(currentFrame, base_dir)\r\n downloadFile(settings.AWS_STORAGE_BUCKET_NAME, frame_path, frame_path)\r\n\r\n return frame_path\r\n\r\n tracker = cv2.TrackerCSRT_create()\r\n currentFrame = self.data['frame']\r\n frame_path = _get_frame(currentFrame, self.base_dir)\r\n frame = cv2.imread(frame_path)\r\n self.results[self.data['id']] = {'results': {}}\r\n\r\n counter = 0\r\n\r\n x = self.data['positions']['x']\r\n y = self.data['positions']['y']\r\n w = self.data['positions']['w']\r\n h = self.data['positions']['h']\r\n\r\n bbox = (x, y, w, h)\r\n\r\n tracker.init(frame, bbox)\r\n\r\n if os.environ.get('WITH_OS') == 'True':\r\n os.remove(frame_path)\r\n\r\n while ((not self.stopped()) and (counter < 10)):\r\n currentFrame += 1\r\n\r\n frame_path = _get_frame(currentFrame, self.base_dir)\r\n frame = cv2.imread(frame_path)\r\n \r\n if frame is None:\r\n break\r\n\r\n ok, bbox = tracker.update(frame)\r\n if os.environ.get('WITH_OS') == 'True':\r\n os.remove(frame_path)\r\n\r\n (x, y, w, h) = [int(v) for v in bbox]\r\n \r\n if (h == 0 and w == 0):\r\n self.results[self.data['id']]['results'][currentFrame] = {'x': x, 'y': y, 'h': h, 'w': w}\r\n break\r\n\r\n self.results[self.data['id']]['results'][currentFrame] = {'x': x, 'y': y, 'h': h, 'w': w}\r\n\r\n key = cv2.waitKey(1) & 0xFF\r\n\r\n counter += 1\r\n\r\ndef track_shapes(data, tid):\r\n base_dir='/home/django/data/%d/data' % (tid)\r\n\r\n results = {}\r\n shape = data['shapes'][0]\r\n\r\n results[shape['id']] = {'results': {}}\r\n thread = CSRTTrackerThread(shape, base_dir, results)\r\n thread.start()\r\n\r\n if tid not in TRACKER_THREADS:\r\n TRACKER_THREADS[tid] = []\r\n\r\n TRACKER_THREADS[tid].append(thread)\r\n\r\n thread.join()\r\n \r\n return results\r\n\r\ndef stop_tracking(tid):\r\n for thread in TRACKER_THREADS[tid]:\r\n thread.stop()\r\n\r\ndef download_vid(tid, currentTask):\r\n base_dir = '/home/django/data/%d/data' % (tid)\r\n vid_dir_path = os.path.join(base_dir, 'video')\r\n if not os.path.isdir(vid_dir_path):\r\n try:\r\n os.mkdir(vid_dir_path)\r\n except OSError as e:\r\n if e.errno == errno.EEXIST:\r\n os.remove(vid_dir_path)\r\n os.mkdir(vid_dir_path)\r\n\r\n if os.environ.get('WITH_OS') == 'True':\r\n bucket = getBucketConnection()\r\n\r\n for object_summary in bucket.objects.filter(Prefix=base_dir + \"/video\"):\r\n currentTask[\"video path\"] = object_summary.key\r\n downloadFile(settings.AWS_STORAGE_BUCKET_NAME, currentTask[\"video path\"], currentTask[\"video path\"])\r\n break\r\n else:\r\n currentTask[\"video path\"] = os.path.join(vid_dir_path, os.listdir(vid_dir_path)[0])\r\n \r\n currentTask[\"downloaded\"] = True\r\n currentTask[\"startedDownloading\"] = False\r\n\r\ndef track_all_video(shape, currentTask):\r\n vs = cv2.VideoCapture(currentTask[\"video path\"].split(\"?\")[0])\r\n\r\n currentFrame = shape['frame']\r\n vs.set(1, currentFrame)\r\n \r\n box = (shape['positions']['x'], shape['positions']['y'], shape['positions']['h'], shape['positions']['w'])\r\n\r\n ok, frame = vs.read()\r\n \r\n # Add a tracker to each box in the frame\r\n tracker = cv2.TrackerCSRT_create()\r\n tracker.init(frame, box)\r\n\r\n while not currentTask[\"shapes\"][shape[\"id\"]][\"stopped\"]:\r\n currentFrame += 1\r\n ok, frame = vs.read()\r\n \r\n if frame is None:\r\n break\r\n \r\n ok, box = tracker.update(frame)\r\n\r\n (x, y, h, w) = [int(v) for v in box]\r\n \r\n if (h == 0 and w == 0):\r\n break\r\n\r\n # If the predicted position is lower than 0 the box is out of bounds.\r\n xtl = x if x > 0 else 0\r\n ytl = y if y > 0 else 0\r\n\r\n # If the predicted position is greater than either the frame width or height the box is out of bounds.\r\n xbr = shape[\"frameWidth\"] if (x + w) > shape[\"frameWidth\"] else (x + w)\r\n ybr = shape[\"frameHeight\"] if (y + h) > shape[\"frameHeight\"] else (y + h)\r\n\r\n currentTask[\"shapes\"][shape[\"id\"]][\"positions\"][currentFrame] = {\"xtl\": xtl, \"ytl\": ytl, \"xbr\": xbr, \"ybr\": ybr, \"occluded\": shape[\"occluded\"], \"z_order\": shape[\"z_order\"], \"outside\": shape[\"outside\"]}\r\n currentTask[\"shapes\"][shape[\"id\"]][\"finished\"] = True\r\n\r\ndef check_video_path(tid):\r\n base_dir = '/home/django/data/%d/data' % (tid)\r\n\r\n if os.environ.get('WITH_OS') == 'False':\r\n return os.path.exists(base_dir + \"/video\")\r\n else: \r\n bucket = getBucketConnection()\r\n\r\n objs = list(bucket.objects.filter(Prefix=base_dir + \"/video\"))\r\n \r\n return len(objs) > 0\r\n\r\ndef watershed(tid, frame, draws, username):\r\n\r\n frame_path = \"/home/django/data/watershed/\" + str(tid) + \"/\" + username + \"/\" + str(frame) + \".jpg\"\r\n watershed_path = get_frame_path(tid, frame).replace('.jpg', '_w.png')\r\n\r\n cvImg = cv2.imread(frame_path)\r\n\r\n print(\"start process\")\r\n overlay = process_watershed(cvImg, draws, tid, frame)\r\n print(\"end process\")\r\n\r\n print(\"start save\")\r\n save_watershed_image(overlay, watershed_path)\r\n print(\"end save\")\r\n \r\n # q = django_rq.get_queue('default')\r\n # q.enqueue_call(func=save_watershed_matrix, args=(tid, frame, matrix),\r\n # job_id=\"task/{}.frame/{}.save_matrix\".format(tid, frame))\r\n\r\n #result['polygons'] = polygons\r\n\r\n #return result\r\n\r\ndef save_watershed_image(image, path):\r\n im = Image.fromarray(image)\r\n im.save(path)\r\n\r\ndef compress_matrix(matrix):\r\n compressedMatrix = []\r\n sequenceCount = 0\r\n prevLabel = matrix[0][0]\r\n\r\n # Each sequence (n elements) of label in matrix is reduced\r\n # to array with 2 elements: [the label, n (sequence count)]\r\n for currLabel in np.nditer(matrix):\r\n if currLabel == prevLabel:\r\n sequenceCount += 1\r\n else:\r\n compressedMatrix.append([prevLabel, sequenceCount])\r\n sequenceCount = 1\r\n\r\n prevLabel = currLabel\r\n\r\n return compressedMatrix\r\n\r\ndef save_watershed_matrix(tid, frame, matrix):\r\n db_task = models.Task.objects.get(pk=tid)\r\n models.Watershed.objects.update_or_create(task=db_task, frame=frame, defaults={'task':db_task, 'frame':frame, 'watershed':compress_matrix(matrix)})\r\n\r\ndef save_paintings(tid, frame, paintings):\r\n db_task = models.Task.objects.get(pk=tid)\r\n models.Watershed.objects.update_or_create(task=db_task, frame=frame, defaults={'task':db_task, 'frame':frame, 'paintings':paintings})\r\n\r\ndef get_paintings(tid, frame):\r\n db_task = models.Task.objects.get(pk=tid)\r\n db_frame_paintings = models.Watershed.objects.filter(task=db_task, frame=frame).first()\r\n\r\n if db_frame_paintings is None:\r\n paintings = []\r\n else:\r\n paintings = db_frame_paintings.paintings\r\n \r\n return paintings\r\n\r\ndef get_task_byjob(jid):\r\n \"\"\"Get the task by the jobid\"\"\"\r\n db_job = models.Job.objects.select_related(\"segment__task\").get(id=jid)\r\n if db_job:\r\n db_segment = db_job.segment\r\n db_task = db_segment.task\r\n\r\n return get(db_task.id)\r\n else:\r\n raise Exception(\"Cannot find the job: {}\".format(jid))\r\n return {}\r\n\r\ndef get_job(jid):\r\n \"\"\"Get the job as dictionary of attributes\"\"\"\r\n db_job = models.Job.objects.select_related(\"segment__task\").get(id=jid)\r\n if db_job:\r\n db_segment = db_job.segment\r\n db_task = db_segment.task\r\n im_meta_data = get_image_meta_cache(db_task)\r\n\r\n # Truncate extra image sizes\r\n if db_task.mode == 'annotation':\r\n im_meta_data['original_size'] = im_meta_data['original_size'][db_segment.start_frame:db_segment.stop_frame + 1]\r\n\r\n db_labels = db_task.label_set.prefetch_related('attributespec_set').order_by('-pk').all()\r\n attributes = {}\r\n for db_label in db_labels:\r\n attributes[db_label.id] = {}\r\n for db_attrspec in db_label.attributespec_set.all():\r\n attributes[db_label.id][db_attrspec.id] = db_attrspec.text\r\n\r\n framePropertiesDict = {\"allProperties\": {}, \"keyframeSpec\": {}}\r\n\r\n # Get all of the task frame spec rows related to the requested task.\r\n taskFrameSpecQuerySet = db_task.taskframespec_set.all()\r\n\r\n # Save the prop name, value name, and relation id for each row in the database for the task in a dictionary\r\n for taskFrameSpec in taskFrameSpecQuerySet:\r\n propName = taskFrameSpec.propVal.prop\r\n valName = taskFrameSpec.propVal.value\r\n propValId = taskFrameSpec.propVal.pk\r\n\r\n # If the propName is not in the dictionary yet, add an empty dictionary to it\r\n if (propName not in framePropertiesDict[\"allProperties\"]):\r\n framePropertiesDict[\"allProperties\"][propName] = {}\r\n framePropertiesDict[\"allProperties\"][propName][valName] = propValId\r\n \r\n keyframes = taskFrameSpec.keyframespec_set.all()\r\n for keyframe in keyframes:\r\n frame = keyframe.frame\r\n if (frame not in framePropertiesDict[\"keyframeSpec\"]):\r\n framePropertiesDict[\"keyframeSpec\"][frame] = {}\r\n framePropertiesDict[\"keyframeSpec\"][frame][propName] = propValId\r\n \r\n labels_colors = models.LabelDetails.objects.filter(labelType__label__in=[db_label.name for db_label in db_labels])\r\n commentsList = list(models.Comments.objects.filter(task=db_task).values_list('frame', 'comment'))\r\n comments = {}\r\n for comment in commentsList:\r\n comments[comment[0]] = comment[1]\r\n \r\n project = serializers.serialize('json', [db_task.project])\r\n\r\n response = {\r\n \"status\": db_job.status,\r\n \"labels\": OrderedDict((db_label.id, db_label.name) for db_label in db_labels),\r\n \"frameProperties\": framePropertiesDict,\r\n \"comments\": comments,\r\n \"segmentation\": {label_color.labelType.label: {\"color\": label_color.color, \"label_type_id\": label_color.labelType.id} for label_color in labels_colors},\r\n \"stop\": db_segment.stop_frame,\r\n \"taskid\": db_task.id,\r\n \"slug\": db_task.name,\r\n \"jobid\": jid,\r\n \"start\": db_segment.start_frame,\r\n \"mode\": db_task.mode,\r\n \"overlap\": db_task.overlap,\r\n \"attributes\": attributes,\r\n \"z_order\": db_task.z_order,\r\n \"flipped\": db_task.flipped,\r\n \"score\": db_task.score,\r\n \"project\": project,\r\n \"image_meta_data\": im_meta_data,\r\n \"max_shape_id\": db_job.max_shape_id,\r\n \"current\": models.Task.objects.get(pk=db_task.id).last_viewed_frame, # db_task.last_viewed_frame returns the previous value from the database\r\n }\r\n else:\r\n raise Exception(\"Cannot find the job: {}\".format(jid))\r\n\r\n return response\r\n\r\n@transaction.atomic\r\ndef rq_handler(job, exc_type, exc_value, traceback):\r\n tid = job.id.split('/')[1]\r\n db_task = models.Task.objects.select_for_update().get(pk=tid)\r\n with open(db_task.get_log_path(), \"wt\") as log_file:\r\n print_exception(exc_type, exc_value, traceback, file=log_file)\r\n db_task.delete()\r\n\r\n return False\r\n\r\ndef nextJobIdByPriority(username, status, tid):\r\n project = models.Task.objects.get(pk=tid).project\r\n if not username == \"staff_user\":\r\n currentUser = User.objects.get(username=username)\r\n opened_tasks = models.Task.objects.filter(project=project, assignee=currentUser, status=status)\r\n else:\r\n currentUser = username \r\n opened_tasks = models.Task.objects.filter(project=project, status=status)\r\n\r\n if opened_tasks.exists():\r\n max_score = opened_tasks.aggregate(maxscore=Max('score'))['maxscore']\r\n\r\n if currentUser == \"staff_user\":\r\n highest_priority_task = models.Task.objects.filter(project=project, status=status, score=max_score)\r\n else:\r\n highest_priority_task = models.Task.objects.filter(project=project, assignee=currentUser, status=status, score=max_score)\r\n\r\n return models.Job.objects.get(segment__task=highest_priority_task[0]).id\r\n else:\r\n return \"No task found\"\r\n\r\n############################# Internal implementation for server API\r\n\r\ndef _make_image_meta_cache(db_task, sorted_filenames=None):\r\n with open(db_task.get_image_meta_cache_path(), 'w') as meta_file:\r\n cache = {\r\n 'original_size': []\r\n }\r\n\r\n if db_task.mode == 'interpolation':\r\n frame_0_url = getFileUrl(get_frame_path(db_task.id, 0))\r\n image = Image.open(frame_0_url)\r\n cache['original_size'].append({\r\n 'width': image.size[0],\r\n 'height': image.size[1]\r\n })\r\n image.close()\r\n else:\r\n filenames = []\r\n\r\n if sorted_filenames is None:\r\n for root, _, files in os.walk(db_task.get_upload_dirname()):\r\n fullnames = map(lambda f: os.path.join(root, f), files)\r\n images = filter(lambda x: _get_mime(x) == 'image', fullnames)\r\n filenames.extend(images)\r\n filenames.sort()\r\n else:\r\n filenames = sorted_filenames\r\n\r\n for image_path in filenames:\r\n image = Image.open(image_path)\r\n cache['original_size'].append({\r\n 'width': image.size[0],\r\n 'height': image.size[1]\r\n })\r\n image.close()\r\n\r\n meta_file.write(str(cache))\r\n\r\ndef get_image_meta_cache(db_task):\r\n try:\r\n with open(db_task.get_image_meta_cache_path()) as meta_cache_file:\r\n return literal_eval(meta_cache_file.read())\r\n except Exception:\r\n _make_image_meta_cache(db_task)\r\n with open(db_task.get_image_meta_cache_path()) as meta_cache_file:\r\n return literal_eval(meta_cache_file.read())\r\n\r\n\r\ndef _get_mime(name):\r\n mime = mimetypes.guess_type(name)\r\n mime_type = mime[0]\r\n encoding = mime[1]\r\n # zip, rar, tar, tar.gz, tar.bz2, 7z, cpio\r\n supportedArchives = ['application/zip', 'application/x-rar-compressed',\r\n 'application/x-tar', 'application/x-7z-compressed', 'application/x-cpio',\r\n 'gzip', 'bzip2']\r\n if mime_type is not None:\r\n if mime_type.startswith('video'):\r\n return 'video'\r\n elif mime_type in supportedArchives or encoding in supportedArchives:\r\n return 'archive'\r\n elif mime_type.startswith('image'):\r\n return 'image'\r\n else:\r\n return 'empty'\r\n else:\r\n if os.path.isdir(name):\r\n return 'directory'\r\n else:\r\n return 'empty'\r\n\r\n\r\ndef _get_frame_path(frame, base_dir):\r\n d1 = str(frame // 10000)\r\n d2 = str(frame // 100)\r\n path = os.path.join(d1, d2, str(frame) + '.jpg')\r\n if base_dir:\r\n path = os.path.join(base_dir, path)\r\n\r\n return path\r\n\r\ndef _parse_frameproperties(frameproperties):\r\n parsed_frameprops = []\r\n for row in frameproperties:\r\n if (row['parent'] != '#' and row['parent'] != '$$$'):\r\n parsed_frameprops.append(row['original']['path'].split(\"/\"))\r\n\r\n return parsed_frameprops\r\n \r\ndef _get_frame_watershed_path(frame, base_dir):\r\n d1 = str(frame // 10000)\r\n d2 = str(frame // 100)\r\n path = os.path.join(d1, d2, str(frame) + '_w.png')\r\n if base_dir:\r\n path = os.path.join(base_dir, path)\r\n\r\n return path\r\n\r\ndef _parse_labels(labels):\r\n parsed_labels = OrderedDict()\r\n\r\n last_label = \"\"\r\n for token in shlex.split(labels):\r\n if token[0] != \"~\" and token[0] != \"@\":\r\n if token in parsed_labels:\r\n raise ValueError(\"labels string is not corect. \" +\r\n \"`{}` label is specified at least twice.\".format(token))\r\n\r\n parsed_labels[token] = {}\r\n last_label = token\r\n else:\r\n attr = models.parse_attribute(token)\r\n attr['text'] = token\r\n if not attr['type'] in ['checkbox', 'radio', 'number', 'text', 'select']:\r\n raise ValueError(\"labels string is not corect. \" +\r\n \"`{}` attribute has incorrect type {}.\".format(\r\n attr['name'], attr['type']))\r\n\r\n values = attr['values']\r\n if attr['type'] == 'checkbox': # <prefix>checkbox=name:true/false\r\n if not (len(values) == 1 and values[0] in ['true', 'false']):\r\n raise ValueError(\"labels string is not corect. \" +\r\n \"`{}` attribute has incorrect value.\".format(attr['name']))\r\n elif attr['type'] == 'number': # <prefix>number=name:min,max,step\r\n try:\r\n if len(values) != 3 or float(values[2]) <= 0 or \\\r\n float(values[0]) >= float(values[1]):\r\n raise ValueError\r\n except ValueError:\r\n raise ValueError(\"labels string is not correct. \" +\r\n \"`{}` attribute has incorrect format.\".format(attr['name']))\r\n\r\n if attr['name'] in parsed_labels[last_label]:\r\n raise ValueError(\"labels string is not corect. \" +\r\n \"`{}` attribute is specified at least twice.\".format(attr['name']))\r\n\r\n parsed_labels[last_label][attr['name']] = attr\r\n\r\n return parsed_labels\r\n\r\ndef _parse_db_labels(db_labels):\r\n result = []\r\n for db_label in db_labels:\r\n result += [db_label.name]\r\n result += [attr.text for attr in db_label.attributespec_set.all()]\r\n return _parse_labels(\" \".join(result))\r\n\r\n\r\n'''\r\n Count all files, remove garbage (unknown mime types or extra dirs)\r\n'''\r\ndef _prepare_paths(source_paths, target_paths, storage):\r\n counters = {\r\n \"image\": 0,\r\n \"directory\": 0,\r\n \"video\": 0,\r\n \"archive\": 0\r\n }\r\n\r\n share_dirs_mapping = {}\r\n share_files_mapping = {}\r\n\r\n if storage == 'local':\r\n # Files were uploaded early. Remove trash if it exists. Count them.\r\n for path in target_paths:\r\n mime = _get_mime(path)\r\n if mime in ['video', 'archive', 'image']:\r\n counters[mime] += 1\r\n else:\r\n try:\r\n os.remove(path)\r\n except:\r\n os.rmdir(path)\r\n else:\r\n # Files are available via mount share. Count them and separate dirs.\r\n for source_path, target_path in zip(source_paths, target_paths):\r\n mime = _get_mime(source_path)\r\n if mime in ['directory', 'image', 'video', 'archive']:\r\n counters[mime] += 1\r\n if mime == 'directory':\r\n share_dirs_mapping[source_path] = target_path\r\n else:\r\n share_files_mapping[source_path] = target_path\r\n\r\n # Remove directories if other files from them exists in input paths\r\n exclude = []\r\n for dir_name in share_dirs_mapping.keys():\r\n for patch in share_files_mapping.keys():\r\n if dir_name in patch:\r\n exclude.append(dir_name)\r\n break\r\n\r\n for excluded_dir in exclude:\r\n del share_dirs_mapping[excluded_dir]\r\n\r\n counters['directory'] = len(share_dirs_mapping.keys())\r\n\r\n return (counters, share_dirs_mapping, share_files_mapping)\r\n\r\n\r\n'''\r\n Check file set on valid\r\n Valid if:\r\n 1 video, 0 images and 0 dirs (interpolation mode)\r\n 1 archive, 0 images and 0 dirs (annotation mode)\r\n Many images or many dirs with images (annotation mode), 0 archives and 0 videos\r\n'''\r\ndef _valid_file_set(counters):\r\n if (counters['image'] or counters['directory']) and (counters['video'] or counters['archive']):\r\n return False\r\n elif counters['video'] > 1 or (counters['video'] and (counters['archive'] or counters['image'] or counters['directory'])):\r\n return False\r\n elif counters['archive'] > 1 or (counters['archive'] and (counters['video'] or counters['image'] or counters['directory'])):\r\n return False\r\n\r\n return True\r\n\r\n\r\n'''\r\n Copy data from share to local\r\n'''\r\ndef _copy_data_from_share(share_files_mapping, share_dirs_mapping):\r\n for source_path in share_dirs_mapping:\r\n copy_tree(source_path, share_dirs_mapping[source_path])\r\n for source_path in share_files_mapping:\r\n target_path = share_files_mapping[source_path]\r\n target_dir = os.path.dirname(target_path)\r\n if not os.path.exists(target_dir):\r\n os.makedirs(target_dir)\r\n shutil.copyfile(source_path, target_path)\r\n\r\n\r\n'''\r\n Find and unpack archive in upload dir\r\n'''\r\ndef _find_and_unpack_archive(upload_dir):\r\n archive = None\r\n for root, _, files in os.walk(upload_dir):\r\n fullnames = map(lambda f: os.path.join(root, f), files)\r\n archives = list(filter(lambda x: _get_mime(x) == 'archive', fullnames))\r\n if len(archives):\r\n archive = archives[0]\r\n break\r\n if archive:\r\n Archive(archive).extractall(upload_dir)\r\n os.remove(archive)\r\n else:\r\n raise Exception('Type defined as archive, but archives were not found.')\r\n\r\n return archive\r\n\r\n\r\n'''\r\n Search a video in upload dir and split it by frames. Copy frames to target dirs\r\n'''\r\ndef _find_and_extract_video(upload_dir, output_dir, db_task, job):\r\n video = None\r\n for root, _, files in os.walk(upload_dir):\r\n fullnames = map(lambda f: os.path.join(root, f), files)\r\n videos = list(filter(lambda x: _get_mime(x) == 'video', fullnames))\r\n if len(videos):\r\n video = videos[0]\r\n break\r\n\r\n if video:\r\n job.meta['status'] = 'Video is being extracted..'\r\n job.save_meta()\r\n _dir, vid_name = os.path.split(video)\r\n uploadFile(video, os.path.join(output_dir, 'video', vid_name))\r\n frame_count = extract_frames(video, output_dir)\r\n db_task.size += frame_count\r\n\r\n else:\r\n raise Exception(\"Video files were not found\")\r\n\r\n return video\r\n\r\ndef count_frames(path):\r\n video = cv2.VideoCapture(path)\r\n total = 0\r\n\r\n # Try to count the frames using opencv property.\r\n # If opencv can't count the frames, count them manually.\r\n try:\r\n # VieoCapture.get returns float value, so we need to convert it to int.\r\n total = int(video.get(cv2.CAP_PROP_FRAME_COUNT))\r\n except:\r\n total = count_frames_manual(video)\r\n \r\n video.release()\r\n\r\n return total\r\n\r\ndef count_frames_manual(video):\r\n total = 0\r\n\r\n # frameExists is a boolean returned from read that indicates wether or not \r\n # a frame was read.\r\n (frameExists, _) = video.read()\r\n \r\n # Continue to iterate over the video frames until the end of the video.\r\n while frameExists: \r\n total += 1\r\n \r\n # video.read() is a function that advances the pointer of the video and\r\n # returns wether or not the frame exists and the frame itself.\r\n (frameExists, _) = video.read()\r\n \r\n return total\r\n\r\ndef get_meta_data(source_path):\r\n meta_data = skvideo.io.ffprobe(source_path)['video']\r\n\r\n if '@nb_frames' not in meta_data:\r\n meta_data['@nb_frames'] = count_frames(source_path)\r\n \r\n return meta_data\r\n\r\ndef extract_frames(source_path, output_dir):\r\n count = 0\r\n threads = []\r\n output = tempfile.mkdtemp(prefix='cvat-', suffix='.data')\r\n target_path = os.path.join(output, '%d.jpg')\r\n LocalImagesPath = target_path\r\n\r\n # create a folder for this video and for entire dataser (if doesnt exist)\r\n _dir, vid_name = os.path.split(source_path)\r\n name = os.path.splitext(vid_name)[0]\r\n save_dir = os.path.abspath(os.path.join(LocalImagesPath, name))\r\n os.makedirs(save_dir)\r\n\r\n # Parse the video\r\n for frame_count, frame in protected_reader(source_path):\r\n if frame is not False:\r\n img_path = os.path.join(save_dir, str(frame_count) + 'jpg')\r\n \r\n #Remove combing lines effect from image\r\n deint_image = deinterlace(frame)\r\n cv2.imwrite(img_path, deint_image[:, :,::-1]) # save image (cv2 uses BGR color channels so reverse)\r\n image_dest_path = _get_frame_path(frame_count, output_dir)\r\n count += 1\r\n dirname = os.path.dirname(image_dest_path)\r\n if not os.path.exists(dirname):\r\n os.makedirs(dirname)\r\n t = copyFileToOSByThread(img_path, image_dest_path)\r\n t.start()\r\n threads.append(t) \r\n\r\n else:\r\n break\r\n\r\n threads = [t for t in threads if t.isAlive()]\r\n for t in threads:\r\n t.join()\r\n \r\n return count\r\n \r\ndef protected_reader(src_path, max_frames=None):\r\n \"\"\"A wrapper reader for skvideo.io.FFmpegReader to avoid crashing on a RuntimeError exception.\r\n\r\n :param src_path: Path to the video file to be read.\r\n :param max_frames: (default=None) Number of frames to read. If left as None will attempt to read the entire video.\r\n :return: A tuple of frame_count, frame\r\n \"\"\"\r\n frame, reader, count = False, None, 0\r\n metadata = get_meta_data(src_path)\r\n if max_frames is None:\r\n max_frames = metadata['@nb_frames']\r\n\r\n video_codec = metadata['@codec_name']\r\n reader = skvideo.io.FFmpegReader(filename=src_path, inputdict={'-vcodec': video_codec})\r\n gen = reader.nextFrame()\r\n\r\n while count < int(max_frames):\r\n try:\r\n frame = gen.__next__()\r\n except Exception:\r\n frame = False\r\n reader.close()\r\n finally:\r\n yield count, frame\r\n count += 1\r\n try:\r\n reader.close()\r\n except Exception:\r\n pass\r\n\r\n\r\ndef deinterlace(image):\r\n interpolation = cv2.INTER_LINEAR # cv2.INTER_NEAREST - fast, looks ok for tagging | cv2.INTER_LINEAR - slower, looks good\r\n\r\n # if sample of image and tags\r\n h, w, c = image.shape\r\n\r\n # cut image in half\r\n temp = image[::2, :, :] if h % 2 == 0 else image[:h-1:2, :, :]\r\n\r\n return cv2.resize(temp, (w, h), interpolation=interpolation)\r\n\r\n'''\r\n Recursive search for all images in upload dir and compress it to RGB jpg with specified quality. Create symlinks for them.\r\n'''\r\ndef _find_and_compress_images(upload_dir, output_dir, db_task, compress_quality, flip_flag, job):\r\n filenames = []\r\n for root, _, files in os.walk(upload_dir):\r\n fullnames = map(lambda f: os.path.join(root, f), files)\r\n images = filter(lambda x: _get_mime(x) == 'image', fullnames)\r\n filenames.extend(images)\r\n filenames.sort()\r\n\r\n _make_image_meta_cache(db_task, filenames)\r\n\r\n if len(filenames):\r\n for idx, name in enumerate(filenames):\r\n job.meta['status'] = 'Images are being compressed.. {}%'.format(idx * 100 // len(filenames))\r\n job.save_meta()\r\n compressed_name = os.path.splitext(name)[0] + '.jpg'\r\n image = Image.open(name).convert('RGB')\r\n if flip_flag:\r\n image = image.transpose(Image.ROTATE_180)\r\n image.save(compressed_name, quality=compress_quality, optimize=True)\r\n image.close()\r\n if compressed_name != name:\r\n os.remove(name)\r\n # PIL::save uses filename in order to define image extension.\r\n # We need save it as jpeg for compression and after rename the file\r\n # Else annotation file will contain invalid file names (with other extensions)\r\n os.rename(compressed_name, name)\r\n\r\n threads = []\r\n for frame, image_orig_path in enumerate(filenames):\r\n image_dest_path = _get_frame_path(frame, output_dir)\r\n image_orig_path = os.path.abspath(image_orig_path)\r\n db_task.size += 1\r\n dirname = os.path.dirname(image_dest_path)\r\n if not os.path.exists(dirname):\r\n os.makedirs(dirname)\r\n os.rename(image_orig_path, image_dest_path)\r\n t = copyFileToOSByThread(image_orig_path, image_dest_path)\r\n t.start()\r\n threads.append(t) \r\n \r\n threads = [t for t in threads if t.isAlive()]\r\n for t in threads:\r\n t.join()\r\n else:\r\n raise Exception(\"Image files were not found\")\r\n\r\n return filenames\r\n\r\ndef _save_task_to_db(db_task, task_params):\r\n\r\n db_task.overlap = min(db_task.size, task_params['overlap'])\r\n db_task.mode = task_params['mode']\r\n db_task.z_order = task_params['z_order']\r\n db_task.flipped = task_params['flip']\r\n db_task.score = task_params['score'] and task_params['score'] or 0 # Set to task_params['score'] unless its undefined, then 0.\r\n db_task.video_id = task_params['video_id']\r\n db_task.source = task_params['data']\r\n\r\n segment_step = task_params['segment'] - db_task.overlap\r\n for x in range(0, db_task.size, segment_step):\r\n start_frame = x\r\n stop_frame = min(x + task_params['segment'] - 1, db_task.size - 1)\r\n slogger.glob.info(\"New segment for task #{}: start_frame = {}, \\\r\n stop_frame = {}\".format(db_task.id, start_frame, stop_frame))\r\n\r\n db_segment = models.Segment()\r\n db_segment.task = db_task\r\n db_segment.start_frame = start_frame\r\n db_segment.stop_frame = stop_frame\r\n db_segment.save()\r\n\r\n db_job = models.Job()\r\n db_job.segment = db_segment\r\n db_job.save()\r\n\r\n parsed_frameprops = _parse_frameproperties(task_params['frame_properties'])\r\n for frameprop in parsed_frameprops:\r\n db_taskframespec = models.TaskFrameSpec()\r\n db_taskframespec.task = db_task\r\n\r\n db_framepropvals = models.FrameProperties.objects.get(prop=frameprop[0], value=frameprop[1], project__pk=db_task.project.pk)\r\n db_taskframespec.propVal = db_framepropvals\r\n db_taskframespec.save()\r\n\r\n parsed_labels = _parse_labels(task_params['labels'])\r\n for label in parsed_labels:\r\n db_label = models.Label()\r\n db_label.task = db_task\r\n db_label.name = label\r\n db_label.save()\r\n\r\n for attr in parsed_labels[label]:\r\n db_attrspec = models.AttributeSpec()\r\n db_attrspec.label = db_label\r\n db_attrspec.text = parsed_labels[label][attr]['text']\r\n db_attrspec.save()\r\n\r\n db_task.save()\r\n\r\ndef _save_paths_to_db(task, files):\r\n count = 0\r\n for currFile in files:\r\n db_task_source = models.TaskSource()\r\n db_task_source.task = task\r\n db_task_source.source_name = currFile\r\n db_task_source.frame = count\r\n count+=1\r\n db_task_source.save()\r\n\r\ndef parseTxtToXml(fileData, taskId):\r\n try:\r\n # Getting image size\r\n frame_0_url = getFileUrl(get_frame_path(taskId, 0))\r\n width, height = Image.open(frame_0_url).size\r\n except Exception:\r\n raise ex\r\n\r\n return (formatter.parse_format(fileData, frame_0_url, width, height))\r\n\r\n\r\n@transaction.atomic\r\ndef _create_thread(tid, params):\r\n def raise_exception(images, dirs, videos, archives):\r\n raise Exception('Only one archive, one video or many images can be dowloaded simultaneously. \\\r\n {} image(s), {} dir(s), {} video(s), {} archive(s) found'.format(images, dirs, videos, archives))\r\n\r\n slogger.glob.info(\"create task #{}\".format(tid))\r\n job = rq.get_current_job()\r\n\r\n db_task = models.Task.objects.select_for_update().get(pk=tid)\r\n upload_dir = db_task.get_upload_dirname()\r\n output_dir = db_task.get_data_dirname()\r\n\r\n counters, share_dirs_mapping, share_files_mapping = _prepare_paths(\r\n params['SOURCE_PATHS'],\r\n params['TARGET_PATHS'],\r\n params['storage']\r\n )\r\n\r\n if (not _valid_file_set(counters)):\r\n raise Exception('Only one archive, one video or many images can be dowloaded simultaneously. \\\r\n {} image(s), {} dir(s), {} video(s), {} archive(s) found'.format(\r\n counters['image'],\r\n counters['directory'],\r\n counters['video'],\r\n counters['archive']\r\n )\r\n )\r\n\r\n archive = None\r\n if counters['archive']:\r\n job.meta['status'] = 'Archive is being unpacked..'\r\n job.save_meta()\r\n archive = _find_and_unpack_archive(upload_dir)\r\n\r\n # Define task mode and other parameters\r\n task_video_id = -1\r\n print(params)\r\n task_score = params['score']\r\n if 'video_id' in params:\r\n task_video_id = params['video_id']\r\n\r\n task_params = {\r\n 'mode': 'annotation' if counters['image'] or counters['directory'] or counters['archive'] else 'interpolation',\r\n 'flip': params['flip_flag'].lower() == 'true',\r\n 'score': task_score,\r\n 'video_id': task_video_id,\r\n 'z_order': params['z_order'].lower() == 'true',\r\n 'compress': int(params.get('compress_quality', 50)),\r\n 'segment': int(sys.maxsize),\r\n 'labels': params['labels'],\r\n 'frame_properties': json.loads(params['frame_properties'])\r\n }\r\n\r\n task_params['overlap'] = int(params.get('overlap_size', 5 if task_params['mode'] == 'interpolation' else 0))\r\n slogger.glob.info(\"Task #{} parameters: {}\".format(tid, task_params))\r\n\r\n files = []\r\n\r\n if task_params['mode'] == 'interpolation':\r\n video = _find_and_extract_video(upload_dir, output_dir, db_task, job)\r\n task_params['data'] = os.path.relpath(video, upload_dir)\r\n else:\r\n files =_find_and_compress_images(upload_dir, output_dir, db_task,\r\n task_params['compress'], task_params['flip'], job)\r\n if archive:\r\n task_params['data'] = os.path.relpath(archive, upload_dir)\r\n else:\r\n task_params['data'] = '{} images: {}, ...'.format(len(files),\r\n \", \".join([os.path.relpath(x, upload_dir) for x in files[0:2]]))\r\n\r\n slogger.glob.info(\"Founded frames {} for task #{}\".format(db_task.size, tid))\r\n\r\n task_params['segment'] = db_task.size + 10\r\n job.meta['status'] = 'Task is being saved in database'\r\n job.save_meta()\r\n\r\n try:\r\n _save_task_to_db(db_task, task_params)\r\n \r\n if task_params['mode'] == 'annotation':\r\n # add sources paths to db\r\n _save_paths_to_db(db_task, params['SOURCE_PATHS'])\r\n\r\n # Parsing taggs file\r\n if params['storage'] == 'share':\r\n txt = parseTxtToXml(upload_dir, db_task.id)\r\n destDir = r'/home/django/data/' + str(db_task.id) + r'/data/xml/'\r\n os.makedirs(destDir)\r\n with open(destDir + r'annotations.txt', 'w') as annotationFile:\r\n annotationFile.write(txt)\r\n except Exception:\r\n pass\r\n finally:\r\n # Deleting upload dir \r\n shutil.rmtree(upload_dir) \r\n"
] |
[
[
"numpy.nditer"
]
] |
gagan3012/metrics
|
[
"5a2388ccaa97cc3608b1fa28879f77436434a6d6"
] |
[
"tests/wrappers/test_bootstrapping.py"
] |
[
"# Copyright The PyTorch Lightning team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport operator\n\nimport numpy as np\nimport pytest\nimport torch\nfrom sklearn.metrics import precision_score, recall_score\nfrom torch import Tensor\n\nfrom torchmetrics.classification import Precision, Recall\nfrom torchmetrics.utilities import apply_to_collection\nfrom torchmetrics.utilities.imports import _TORCH_GREATER_EQUAL_1_7\nfrom torchmetrics.wrappers.bootstrapping import BootStrapper, _bootstrap_sampler\n\n_preds = torch.randint(10, (10, 32))\n_target = torch.randint(10, (10, 32))\n\n\nclass TestBootStrapper(BootStrapper):\n \"\"\"For testing purpose, we subclass the bootstrapper class so we can get the exact permutation the class is\n creating.\"\"\"\n\n def update(self, *args) -> None:\n self.out = []\n for idx in range(self.num_bootstraps):\n size = len(args[0])\n sample_idx = _bootstrap_sampler(size, sampling_strategy=self.sampling_strategy)\n new_args = apply_to_collection(args, Tensor, torch.index_select, dim=0, index=sample_idx)\n self.metrics[idx].update(*new_args)\n self.out.append(new_args)\n\n\ndef _sample_checker(old_samples, new_samples, op: operator, threshold: int):\n found_one = False\n for os in old_samples:\n cond = op(os, new_samples)\n if cond.sum() > threshold:\n found_one = True\n break\n return found_one\n\n\n@pytest.mark.parametrize(\"sampling_strategy\", [\"poisson\", \"multinomial\"])\ndef test_bootstrap_sampler(sampling_strategy):\n \"\"\"make sure that the bootstrap sampler works as intended.\"\"\"\n old_samples = torch.randn(10, 2)\n\n # make sure that the new samples are only made up of old samples\n idx = _bootstrap_sampler(10, sampling_strategy=sampling_strategy)\n new_samples = old_samples[idx]\n for ns in new_samples:\n assert ns in old_samples\n\n found_one = _sample_checker(old_samples, new_samples, operator.eq, 2)\n assert found_one, \"resampling did not work because no samples were sampled twice\"\n\n found_zero = _sample_checker(old_samples, new_samples, operator.ne, 0)\n assert found_zero, \"resampling did not work because all samples were atleast sampled once\"\n\n\n@pytest.mark.parametrize(\"sampling_strategy\", [\"poisson\", \"multinomial\"])\n@pytest.mark.parametrize(\n \"metric, sk_metric\", [[Precision(average=\"micro\"), precision_score], [Recall(average=\"micro\"), recall_score]]\n)\ndef test_bootstrap(sampling_strategy, metric, sk_metric):\n \"\"\"Test that the different bootstraps gets updated as we expected and that the compute method works.\"\"\"\n _kwargs = {\"base_metric\": metric, \"mean\": True, \"std\": True, \"raw\": True, \"sampling_strategy\": sampling_strategy}\n if _TORCH_GREATER_EQUAL_1_7:\n _kwargs.update(dict(quantile=torch.tensor([0.05, 0.95])))\n\n bootstrapper = TestBootStrapper(**_kwargs)\n\n collected_preds = [[] for _ in range(10)]\n collected_target = [[] for _ in range(10)]\n for p, t in zip(_preds, _target):\n bootstrapper.update(p, t)\n\n for i, o in enumerate(bootstrapper.out):\n\n collected_preds[i].append(o[0])\n collected_target[i].append(o[1])\n\n collected_preds = [torch.cat(cp) for cp in collected_preds]\n collected_target = [torch.cat(ct) for ct in collected_target]\n\n sk_scores = [sk_metric(ct, cp, average=\"micro\") for ct, cp in zip(collected_target, collected_preds)]\n\n output = bootstrapper.compute()\n # quantile only avaible for pytorch v1.7 and forward\n if _TORCH_GREATER_EQUAL_1_7:\n assert np.allclose(output[\"quantile\"][0], np.quantile(sk_scores, 0.05))\n assert np.allclose(output[\"quantile\"][1], np.quantile(sk_scores, 0.95))\n\n assert np.allclose(output[\"mean\"], np.mean(sk_scores))\n assert np.allclose(output[\"std\"], np.std(sk_scores, ddof=1))\n assert np.allclose(output[\"raw\"], sk_scores)\n"
] |
[
[
"numpy.quantile",
"torch.cat",
"numpy.mean",
"numpy.allclose",
"torch.randint",
"numpy.std",
"torch.tensor",
"torch.randn"
]
] |
idk3/Cirq
|
[
"1f82a72bda689895753e9a32c8b991fd5057854b"
] |
[
"cirq/contrib/acquaintance/gates_test.py"
] |
[
"# Copyright 2018 The Cirq Developers\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom itertools import product\nfrom string import ascii_lowercase as alphabet\nfrom typing import Sequence, Tuple\n\nfrom numpy.random import poisson\nimport pytest\n\nimport cirq\nfrom cirq.contrib.acquaintance.gates import (\n ACQUAINT, SwapNetworkGate, op_acquaintance_size)\nfrom cirq.contrib.acquaintance.shift import CircularShiftGate\nfrom cirq.contrib.acquaintance.permutation import (\n update_mapping, LinearPermutationGate)\n\n\ndef test_acquaintance_gate_repr():\n assert repr(ACQUAINT) == 'Acq'\n\ndef test_acquaintance_gate_text_diagram_info():\n qubits = [cirq.NamedQubit(s) for s in 'xyz']\n circuit = cirq.Circuit([cirq.Moment([ACQUAINT(*qubits)])])\n actual_text_diagram = circuit.to_text_diagram().strip()\n expected_text_diagram = \"\"\"\nx: ───█───\n │\ny: ───█───\n │\nz: ───█───\n \"\"\".strip()\n assert actual_text_diagram == expected_text_diagram\n\ndef test_acquaintance_gate_unknown_qubit_count():\n g = ACQUAINT\n args = cirq.TextDiagramInfoArgs.UNINFORMED_DEFAULT\n assert g.text_diagram_info(args) == NotImplemented\n\n\ndef test_swap_network_gate():\n qubits = tuple(cirq.NamedQubit(s) for s in alphabet)\n\n acquaintance_size = 3\n n_parts = 3\n part_lens = (acquaintance_size - 1,) * n_parts\n n_qubits = sum(part_lens)\n swap_network_op = SwapNetworkGate(part_lens,\n acquaintance_size=acquaintance_size)(*qubits[:n_qubits])\n swap_network = cirq.Circuit.from_ops(swap_network_op)\n actual_text_diagram = swap_network.to_text_diagram().strip()\n expected_text_diagram = \"\"\"\na: ───×(0,0)───\n │\nb: ───×(0,1)───\n │\nc: ───×(1,0)───\n │\nd: ───×(1,1)───\n │\ne: ───×(2,0)───\n │\nf: ───×(2,1)───\n \"\"\".strip()\n assert actual_text_diagram == expected_text_diagram\n\n no_decomp = lambda op: isinstance(op.gate,\n (CircularShiftGate, LinearPermutationGate))\n expander = cirq.ExpandComposite(no_decomp=no_decomp)\n expander(swap_network)\n actual_text_diagram = swap_network.to_text_diagram().strip()\n expected_text_diagram = \"\"\"\na: ───█───────╲0╱───█─────────────────█───────────╲0╱───█───────0↦1───\n │ │ │ │ │ │ │\nb: ───█───█───╲1╱───█───█─────────────█───█───────╲1╱───█───█───1↦0───\n │ │ │ │ │ │ │ │ │ │\nc: ───█───█───╱2╲───█───█───█───╲0╱───█───█───█───╱2╲───█───█───0↦1───\n │ │ │ │ │ │ │ │ │ │\nd: ───────█───╱3╲───█───█───█───╲1╱───█───█───█───╱3╲───────█───1↦0───\n │ │ │ │ │\ne: ─────────────────█───────█───╱2╲───█───────█───0↦1─────────────────\n │ │ │ │\nf: ─────────────────█───────────╱3╲───█───────────1↦0─────────────────\n \"\"\".strip()\n assert actual_text_diagram == expected_text_diagram\n\n no_decomp = lambda op: isinstance(op.gate, CircularShiftGate)\n expander = cirq.ExpandComposite(no_decomp=no_decomp)\n\n acquaintance_size = 3\n n_parts = 6\n part_lens = (1,) * n_parts\n n_qubits = sum(part_lens)\n swap_network_op = SwapNetworkGate(part_lens,\n acquaintance_size=acquaintance_size)(*qubits[:n_qubits])\n swap_network = cirq.Circuit.from_ops(swap_network_op)\n\n expander(swap_network)\n actual_text_diagram = swap_network.to_text_diagram().strip()\n expected_text_diagram = \"\"\"\na: ───╲0╱─────────╲0╱─────────╲0╱─────────\n │ │ │\nb: ───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───\n │ │ │\nc: ───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───\n │ │ │\nd: ───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───\n │ │ │\ne: ───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───\n │ │ │\nf: ───╱1╲─────────╱1╲─────────╱1╲─────────\n \"\"\".strip()\n assert actual_text_diagram == expected_text_diagram\n\n@pytest.mark.parametrize('part_lens, acquaintance_size',\n list(((part_len,) * n_parts, acquaintance_size) for\n part_len, acquaintance_size, n_parts in\n product(range(1, 5), range(5), range(2, 5)))\n )\ndef test_swap_network_gate_permutation(part_lens, acquaintance_size):\n n_qubits = sum(part_lens)\n qubits = cirq.LineQubit.range(n_qubits)\n swap_network_gate = SwapNetworkGate(part_lens, acquaintance_size)\n operations = swap_network_gate.default_decompose(qubits)\n operations = list(cirq.flatten_op_tree(operations))\n mapping = {q: i for i, q in enumerate(qubits)}\n update_mapping(mapping, operations)\n assert mapping == {q: i for i, q in enumerate(reversed(qubits))}\n\ndef test_swap_network_gate_from_ops():\n n_qubits = 10\n qubits = cirq.LineQubit.range(n_qubits)\n part_lens = (1, 2, 1, 3, 3)\n operations = [cirq.Z(qubits[0]),\n cirq.CZ(*qubits[1:3]),\n cirq.CCZ(*qubits[4:7]),\n cirq.CCZ(*qubits[7:])]\n acquaintance_size = 3\n swap_network = SwapNetworkGate.from_operations(\n qubits, operations, acquaintance_size)\n assert swap_network.acquaintance_size == acquaintance_size\n assert swap_network.part_lens == part_lens\n\n\ndef test_swap_network_decomposition():\n qubits = cirq.LineQubit.range(8)\n swap_network_gate = SwapNetworkGate((4, 4), 5)\n operations = swap_network_gate.default_decompose(qubits)\n circuit = cirq.Circuit.from_ops(operations)\n actual_text_diagram = circuit.to_text_diagram()\n expected_text_diagram = \"\"\"\n0: ───█─────────────█─────────────╲0╱─────────────█─────────█───────0↦2───\n │ │ │ │ │ │\n1: ───█─────────────█─────────────╲1╱─────────────█─────────█───────1↦3───\n │ │ │ │ │ │\n2: ───█─────────────█───1↦0───────╲2╱───────1↦0───█─────────█───────2↦0───\n │ │ │ │ │ │ │ │\n3: ───█───█─────────█───0↦1───█───╲3╱───█───0↦1───█─────────█───█───3↦1───\n │ │ │ │ │ │ │ │ │\n4: ───█───█───0↦1───█─────────█───╱4╲───█─────────█───0↦1───█───█───0↦2───\n │ │ │ │ │ │ │ │\n5: ───────█───1↦0─────────────█───╱5╲───█─────────────1↦0───────█───1↦3───\n │ │ │ │ │ │\n6: ───────█───────────────────█───╱6╲───█───────────────────────█───2↦0───\n │ │ │ │ │ │\n7: ───────█───────────────────█───╱7╲───█───────────────────────█───3↦1───\n \"\"\".strip()\n assert actual_text_diagram == expected_text_diagram\n\ndef test_swap_network_init_error():\n with pytest.raises(ValueError):\n SwapNetworkGate(())\n with pytest.raises(ValueError):\n SwapNetworkGate((3,))\n\n@pytest.mark.parametrize('part_lens, acquaintance_size', [\n [[l + 1 for l in poisson(size=n_parts, lam=lam)], poisson(4)]\n for n_parts, lam in product(range(2, 20, 3), range(1, 4))\n ])\ndef test_swap_network_permutation(part_lens, acquaintance_size):\n n_qubits = sum(part_lens)\n gate = SwapNetworkGate(part_lens, acquaintance_size)\n\n expected_permutation = {i: j for i, j in\n zip(range(n_qubits), reversed(range(n_qubits)))}\n assert gate.permutation(n_qubits) == expected_permutation\n\ndef test_swap_network_permutation_error():\n gate = SwapNetworkGate((1, 1))\n with pytest.raises(ValueError):\n gate.permutation(1)\n\nclass OtherOperation(cirq.Operation):\n def __init__(self, qubits: Sequence[cirq.QubitId]) -> None:\n self._qubits = tuple(qubits)\n\n @property\n def qubits(self) -> Tuple[cirq.QubitId, ...]:\n return self._qubits\n\n def with_qubits(self, *new_qubits: cirq.QubitId) -> 'OtherOperation':\n return type(self)(self._qubits)\n\n def __eq__(self, other):\n return (isinstance(other, type(self)) and\n self.qubits == other.qubits)\n\ndef test_op_acquaintance_size():\n qubits = cirq.LineQubit.range(5)\n op = OtherOperation(qubits)\n assert op.with_qubits(qubits) == op\n assert op_acquaintance_size(op) == 0\n\n for s, _ in enumerate(qubits):\n op = ACQUAINT(*qubits[:s + 1])\n assert op_acquaintance_size(op) == s + 1\n\n part_lens = (2, 2, 2, 2)\n acquaintance_size = 3\n gate = SwapNetworkGate(part_lens, acquaintance_size)\n op = gate(*qubits[:sum(part_lens)])\n assert op_acquaintance_size(op) == 3\n\n part_lens = (2, 2, 2, 2)\n acquaintance_size = 4\n gate = SwapNetworkGate(part_lens, acquaintance_size)\n op = gate(*qubits[:sum(part_lens)])\n assert op_acquaintance_size(op) == 0\n\n part_lens = (2, 2, 2, 2)\n acquaintance_size = 1\n gate = SwapNetworkGate(part_lens, acquaintance_size)\n op = gate(*qubits[:sum(part_lens)])\n assert op_acquaintance_size(op) == 0\n\n part_lens = (2, 2, 2, 2)\n acquaintance_size = 1\n gate = SwapNetworkGate(part_lens, acquaintance_size)\n op = gate(*qubits[:sum(part_lens)])\n assert op_acquaintance_size(op) == 0\n"
] |
[
[
"numpy.random.poisson"
]
] |
mwsssxu/tutorials
|
[
"e2742ea7171e3829ea628bac483e8787be60bbd3"
] |
[
"sklearnTUT/sk10_cross_validation3.py"
] |
[
"# View more python learning tutorial on my Youtube and Youku channel!!!\n\n# Youtube video tutorial: https://www.youtube.com/channel/UCdyjiB5H8Pu7aDTNVXTTpcg\n# Youku video tutorial: http://i.youku.com/pythontutorial\n\n\"\"\"\nPlease note, this code is only for python 3+. If you are using python 2+, please modify the code accordingly.\n\"\"\"\nfrom __future__ import print_function\nfrom sklearn.model_selection import validation_curve\nfrom sklearn.datasets import load_digits\nfrom sklearn.svm import SVC\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndigits = load_digits()\nX = digits.data\ny = digits.target\nparam_range = np.logspace(-6, -2.3, 5)\ntrain_loss, test_loss = validation_curve(\n SVC(), X, y, param_name='gamma', param_range=param_range, cv=10,\n scoring='neg_mean_squared_error')\ntrain_loss_mean = -np.mean(train_loss, axis=1)\ntest_loss_mean = -np.mean(test_loss, axis=1)\n\nplt.plot(param_range, train_loss_mean, 'o-', color=\"r\",\n label=\"Training\")\nplt.plot(param_range, test_loss_mean, 'o-', color=\"g\",\n label=\"Cross-validation\")\n\nplt.xlabel(\"gamma\")\nplt.ylabel(\"Loss\")\nplt.legend(loc=\"best\")\nplt.show()\n"
] |
[
[
"sklearn.datasets.load_digits",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"numpy.mean",
"sklearn.svm.SVC",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.show",
"numpy.logspace"
]
] |
rykiprince/Mission-to-Mars
|
[
"ef800c7d5b1c5a4b4dcd51e371bf0be0e2513ed4"
] |
[
"Mission_to_Mars_Challenge.py"
] |
[
"# Import Splinter and BeautifulSoup\nfrom splinter import Browser\nfrom bs4 import BeautifulSoup as soup\nfrom webdriver_manager.chrome import ChromeDriverManager\n\nimport pandas as pd\n\n\nexecutable_path = {'executable_path': ChromeDriverManager().install()}\nbrowser = Browser('chrome',**executable_path, headless=False)\n\n\n# Visit the mars nasa news site\nurl = 'https://redplanetscience.com'\nbrowser.visit(url)\n# Optional delay for loading the page\nbrowser.is_element_present_by_css('div.list_text', wait_time=1)\n\n\n#Set up the HTML parser\nhtml = browser.html\nnews_soup = soup(html, 'html.parser')\nslide_elem = news_soup.select_one('div.list_text')\n\n# Begin scraping\nslide_elem.find('div', class_='content_title')\n\n\n\n\n# Use the parent element to find the first `a` tag and save it as `news_title`\nnews_title = slide_elem.find('div', class_='content_title').get_text()\nnews_title\n\n\n\n\nslide_elem.find('div', class_='article_teaser_body')\n\n\n\n# Use the parent element to find the paragraph text\nnews_p = slide_elem.find('div', class_='article_teaser_body').get_text()\nnews_p\n\n\n# ### Featured Images\n\n# Visit URL\nurl = 'https://spaceimages-mars.com'\nbrowser.visit(url)\n\n\n# Find and click the full image button\nfull_image_elem = browser.find_by_tag('button')[1]\nfull_image_elem.click()\n\n\n\n\n# Parse the resulting html with soup\nhtml = browser.html\nimg_soup = soup(html, 'html.parser')\n\n\n# Find the relative image url\nimg_url_rel = img_soup.find('img', class_='fancybox-image').get('src')\nimg_url_rel\n\n\n# Use the base URL to create an absolute URL\nimg_url = f'https://spaceimages-mars.com/{img_url_rel}'\nimg_url\n\n\ndf = pd.read_html('https://galaxyfacts-mars.com')[0]\ndf.columns=['description', 'Mars', 'Earth']\ndf.set_index('description', inplace=True)\ndf\n\n\ndf.to_html()\n\nbrowser.quit()\n\n\n# # D1: Scrape High-Resolution Mars’ Hemisphere Images and Titles\n\n# Hemispheres\n\n# Import Splinter and BeautifulSoup\nfrom splinter import Browser\nfrom bs4 import BeautifulSoup as soup\nfrom webdriver_manager.chrome import ChromeDriverManager \nimport pandas as pd\n\nexecutable_path = {'executable_path': ChromeDriverManager().install()}\nbrowser = Browser('chrome',**executable_path, headless=False)\n\n# 1. Use browser to visit the URL \nurl = 'https://astrogeology.usgs.gov/search/results?q=hemisphere+enhanced&k1=target&v1=Mars'\nbrowser.visit(url)\n\n# 2. Create a list to hold the images and titles.\nhemisphere_image_urls = []\n\n# 3. Write code to retrieve the image urls and titles for each hemisphere.\n# links for all hemisphere\n\nlinks = browser.find_by_css('a.product-item h3')\n\n# # Loop through each link\nfor index in range(len(links)):\n\n hemispheres = {}\n browser.find_by_css('a.product-item h3')[index].click()\n # navigate to the full-resolution image page\n# html = browser.html\n# hemi_soup = soup(html, 'html.parser')\n \n sample_rel = browser.links.find_by_text('Sample').first\n\n # retrieve the full-resolution image URL string and title for the hemisphere image\n hemispheres[\"img_url\"] = sample_rel[\"href\"]\n\n hemispheres[\"title\"] = browser.find_by_css(\"h2.title\").value\n \n hemisphere_image_urls.append(hemispheres)\n\n # Use `browser.back()` to navigate back to the beginning to get the mext hemisphere image.\n browser.back()\n\n# 4. Print the list that holds the dictionary of each image url and title.\nhemisphere_image_urls\n\n# 5. Quit the browser\nbrowser.quit()\n\n"
] |
[
[
"pandas.read_html"
]
] |
S-Eggers/GraphMask
|
[
"9e431a541279801ec46a5b38ed57b2033f795240"
] |
[
"code/problems/qa/qa_model.py"
] |
[
"import scipy\nfrom torch.nn import Dropout, CrossEntropyLoss\n\nfrom code.abstract.abstract_torch_module import AbstractTorchModule\nimport torch\nimport numpy as np\n\nfrom code.gnns.qa_gnn import QaGNN\nfrom code.utils.evaluation.choice_model_output import ChoiceModelOutput\nfrom code.utils.torch_utils.xavier_linear import XavierLinear\n\n\nclass QAModel(AbstractTorchModule):\n n_edge_types = 4\n\n def __init__(self, configuration):\n AbstractTorchModule.__init__(self)\n\n self.layers = configuration[\"model_parameters\"][\"gnn_layers\"]\n self.configuration = configuration\n self.max_nodes = configuration[\"task\"][\"max_nodes\"]\n self.max_query_size = configuration[\"task\"][\"max_query_size\"]\n self.max_candidates = configuration[\"task\"][\"max_candidates\"]\n\n embedding_input_dim = 300\n\n self.gcn = QaGNN(dim=512,\n n_layers=self.layers,\n n_relations=self.n_edge_types,\n share_parameters=True)\n\n self.node_compress_mlp = torch.nn.Sequential(XavierLinear(embedding_input_dim, 256),\n torch.nn.Tanh(),\n torch.nn.Dropout(p=0.2))\n\n self.node_mlp = torch.nn.Sequential(XavierLinear(512, 1024),\n torch.nn.Tanh(),\n torch.nn.Dropout(p=0.2),\n XavierLinear(1024, 512),\n torch.nn.Tanh(),\n torch.nn.Dropout(p=0.2))\n\n # self.lstm = LSTM(3072, 256, 2, batch_first=True, bidirectional=True)\n\n self.lstm1 = torch.nn.LSTM(embedding_input_dim, 256, num_layers=1, batch_first=True, bidirectional=True,\n dropout=0)\n self.lstm2 = torch.nn.LSTM(512, 128, num_layers=1, batch_first=True, bidirectional=True, dropout=0)\n self.query_dropout = Dropout(p=0.2)\n\n self.second_mlp = torch.nn.Sequential(XavierLinear(768, 128),\n torch.nn.Tanh(),\n XavierLinear(128, 1),\n torch.nn.Dropout(p=0.2))\n\n self.loss = CrossEntropyLoss(reduction=\"none\")\n\n def forward(self, batch):\n processed_batch = self.process_batch(batch)\n\n this_batch_max_nodes = max(processed_batch[\"nodes_length_mb\"])\n normalized_batch_adj_mats = torch.FloatTensor(processed_batch[\"adj_mb\"]).to(self.device)[:, :,\n :this_batch_max_nodes, :this_batch_max_nodes]\n\n query = torch.FloatTensor(processed_batch[\"query_mb\"]).to(self.device).view(len(batch), self.max_query_size, -1)\n query_lengths = torch.LongTensor(processed_batch[\"query_length_mb\"]).to(self.device)\n\n packed_representation = torch.nn.utils.rnn.pack_padded_sequence(query, query_lengths.cpu(),\n batch_first=True, enforce_sorted=False)\n\n lstm1_output, _ = self.lstm1(packed_representation)\n _, (query_lasthidden, _) = self.lstm2(lstm1_output)\n\n final_output = query_lasthidden.transpose(1, 0).reshape(len(batch), -1)\n final_output = self.query_dropout(final_output)\n\n query_to_node = final_output.unsqueeze(1).repeat(1, this_batch_max_nodes, 1)\n nodes = torch.FloatTensor(processed_batch[\"nodes_mb\"]).to(self.device).view(len(batch), self.max_nodes, -1)[:,\n :this_batch_max_nodes, :]\n node_lengths = torch.LongTensor(processed_batch[\"nodes_length_mb\"]).to(self.device)\n\n node_mask = torch.arange(this_batch_max_nodes, dtype=torch.long).to(self.device).expand(node_lengths.shape[0],\n this_batch_max_nodes) < node_lengths.unsqueeze(\n 1)\n node_mask = node_mask.unsqueeze(-1).float()\n\n nodes *= node_mask\n query_to_node *= node_mask\n\n nodes = self.node_compress_mlp(nodes)\n\n nodes = torch.cat([query_to_node, nodes], -1)\n nodes = self.node_mlp(nodes)\n\n vertex_embeddings = self.gcn(nodes, normalized_batch_adj_mats, mask=node_mask)\n\n vertex_embeddings = vertex_embeddings.view(len(batch), this_batch_max_nodes, -1)\n final_vertex_embeddings = torch.cat([query_to_node, vertex_embeddings], -1)\n final_vertex_embeddings = self.second_mlp(final_vertex_embeddings)\n\n final_vertex_embeddings *= node_mask\n\n bmask = torch.FloatTensor(processed_batch[\"bmask_mb\"]).to(self.device)[:, :, :this_batch_max_nodes]\n\n final_vertex_embeddings = final_vertex_embeddings.squeeze(-1).unsqueeze(1)\n\n candidate_embeddings = bmask * final_vertex_embeddings\n cand_unconnected = candidate_embeddings == 0\n\n cand_n_connections = (1 - cand_unconnected.float()).sum(dim=-1)\n cand_connected = torch.min(cand_n_connections, torch.ones_like(cand_n_connections))\n\n candidate_embeddings = torch.where(cand_unconnected, torch.ones_like(candidate_embeddings) * -1e8,\n candidate_embeddings)\n\n candidate_embeddings, _ = torch.max(candidate_embeddings, dim=-1)\n\n answers = torch.LongTensor(processed_batch[\"answer_positions_mb\"]).to(self.device)\n\n gold_candidate_connected = cand_connected[torch.arange(cand_connected.size(0)), answers]\n\n # This is a bit hacky, might want to refactor.\n # We only see negative targets at test time when the answer is not a mention, so we could actually skip\n # computing the loss entirely in those cases.\n loss_targets = torch.max(answers, torch.zeros_like(answers))\n loss = (self.loss(candidate_embeddings, loss_targets) * gold_candidate_connected).mean()\n\n scores = torch.softmax(candidate_embeddings, dim=-1).detach().cpu().numpy()\n\n predictions = []\n for i, example in enumerate(batch):\n example_scores = scores[i]\n example_gold = example[\"answer_position\"]\n\n example_output = ChoiceModelOutput(example_scores, example_gold)\n predictions.append(example_output)\n\n return loss, predictions\n\n def get_gnn(self):\n return self.gcn\n\n def process_batch(self, data_mb):\n answers_mb = [d[\"answer_position\"] for d in data_mb]\n\n id_mb = [d['id'] for d in data_mb]\n\n candidates_orig_mb = [d['candidates_orig'] for d in data_mb]\n candidates_orig_mb2 = [d['candidates_orig2'] for d in data_mb]\n\n candidates_mb = [d['candidates'] for d in data_mb]\n\n nodes_mb = np.array([np.pad(np.array([c.mean(0) for c in d['nodes_glove']]),\n ((0, self.max_nodes - len(d['nodes_candidates_id'])), (0, 0)),\n mode='constant')\n for d in data_mb])\n\n query_mb = np.stack([np.pad(d['query_glove'],\n ((0, self.max_query_size - d['query_glove'].shape[0]), (0, 0)),\n mode='constant')\n for d in data_mb], 0)\n\n nodes_length_mb = np.stack([len(d['nodes_candidates_id']) for d in data_mb], 0)\n query_length_mb = np.stack([d['query_glove'].shape[0] for d in data_mb], 0)\n\n adj_mb = []\n for d in data_mb:\n\n adj_ = []\n\n if len(d['edges_in']) == 0:\n adj_.append(np.zeros((self.max_nodes, self.max_nodes)))\n else:\n adj = scipy.sparse.coo_matrix((np.ones(len(d['edges_in'])), np.array(d['edges_in']).T),\n shape=(self.max_nodes, self.max_nodes)).toarray()\n\n adj_.append(adj)\n\n if len(d['edges_out']) == 0:\n adj_.append(np.zeros((self.max_nodes, self.max_nodes)))\n else:\n adj = scipy.sparse.coo_matrix((np.ones(len(d['edges_out'])), np.array(d['edges_out']).T),\n shape=(self.max_nodes, self.max_nodes)).toarray()\n\n adj_.append(adj)\n\n if len(d['edges_coref']) == 0:\n adj_.append(np.zeros((self.max_nodes, self.max_nodes)))\n else:\n adj = scipy.sparse.coo_matrix((np.ones(len(d['edges_coref'])), np.array(d['edges_coref']).T),\n shape=(self.max_nodes, self.max_nodes)).toarray()\n\n adj_.append(adj)\n\n adj = np.pad(np.ones((len(d['nodes_candidates_id']), len(d['nodes_candidates_id']))),\n ((0, self.max_nodes - len(d['nodes_candidates_id'])),\n (0, self.max_nodes - len(d['nodes_candidates_id']))), mode='constant') \\\n - adj_[0] - adj_[1] - adj_[2] - np.pad(np.eye(len(d['nodes_candidates_id'])),\n ((0, self.max_nodes - len(d['nodes_candidates_id'])),\n (0, self.max_nodes - len(d['nodes_candidates_id']))),\n mode='constant')\n\n adj_.append(np.clip(adj, 0, 1))\n\n adj = np.stack(adj_, 0)\n\n d_ = adj.sum(-1)\n d_[np.nonzero(d_)] **= -1\n adj = adj * np.expand_dims(d_, -1)\n\n adj_mb.append(adj)\n\n adj_mb = np.array(adj_mb)\n\n bmask_mb = np.array([np.pad(np.array([i == np.array(d['nodes_candidates_id'])\n for i in range(len(d['candidates']))]),\n ((0, self.max_candidates - len(d['candidates'])),\n (0, self.max_nodes - len(d['nodes_candidates_id']))), mode='constant')\n for d in data_mb])\n\n return {'id_mb': id_mb, 'nodes_mb': nodes_mb, 'nodes_length_mb': nodes_length_mb,\n 'query_mb': query_mb, 'query_length_mb': query_length_mb, 'bmask_mb': bmask_mb,\n 'adj_mb': adj_mb, 'candidates_mb': candidates_mb, 'candidates_orig_mb': candidates_orig_mb,\n 'candidates_orig_mb2': candidates_orig_mb2, \"answer_positions_mb\": answers_mb}"
] |
[
[
"torch.cat",
"torch.nn.LSTM",
"torch.LongTensor",
"torch.nn.CrossEntropyLoss",
"torch.FloatTensor",
"numpy.nonzero",
"torch.zeros_like",
"numpy.expand_dims",
"numpy.array",
"numpy.pad",
"numpy.zeros",
"torch.max",
"torch.nn.Tanh",
"numpy.stack",
"numpy.clip",
"torch.nn.Dropout",
"torch.arange",
"torch.softmax",
"torch.ones_like"
]
] |
JinLi97/recommender-system-dev-workshop-code
|
[
"e2673360f3dfaa561f35fa4d50b8726bc46cd80d"
] |
[
"src/offline/movie/recall-batch/service_impl.py"
] |
[
"import logging\nimport numpy as np\nimport json\nimport itertools\n\nlogging.basicConfig(level=logging.INFO)\n\n\nclass ServiceImpl:\n\n def __init__(self,\n recall_per_news_id=10,\n similar_entity_threshold=20,\n recall_threshold=2.0,\n recall_merge_number=20,\n entity_index_l={},\n word_index_l={},\n entity_embedding_l=[]):\n\n logging.info('Initial Service implementation...')\n logging.info(\n 'recall_per_news_id = %s, similar_entity_threshold=%s, recall_threshold=%s, recall_merge_number=%s',\n recall_per_news_id,\n similar_entity_threshold,\n recall_threshold,\n recall_merge_number\n )\n #\n self.recall_per_news_id = int(recall_per_news_id)\n self.similar_entity_threshold = int(similar_entity_threshold)\n self.recall_threshold = float(recall_threshold)\n self.recall_merge_number = int(recall_merge_number)\n self.entity_index = entity_index_l\n self.word_index = word_index_l\n self.entity_embedding = entity_embedding_l\n\n def analyze_shot_record(self, record, id):\n if id in record.keys():\n current_count = record[id]\n record[id] = record[id] + 1\n else:\n record[id] = 1\n\n # 根据召回位置打分；记录命中的次数；去重\n def recall_pos_score(self, src_item, topn_list, param, shot_record):\n list_with_score = []\n for pos, idx in enumerate(topn_list):\n if src_item != str(idx):\n current_idx_with_score = {}\n current_idx_with_score['id'] = str(idx)\n current_idx_with_score['score'] = (len(topn_list) - 1 - pos) * param['w'] + param['b']\n self.analyze_shot_record(shot_record, str(idx))\n list_with_score.append(current_idx_with_score)\n return list_with_score\n\n def recall_by_popularity(self, news_ids, recall_wrap, recall_items, multiple_shot_record):\n # 根据最近阅读的记录召回\n # 1. category: 类别\n # 2. director: 导演\n # 3. actor: 演员\n # 4. language: 语言\n # 5. level: 分级 \n # 6. year: 年限 \n dict_id_content = recall_wrap['content']\n dict_wrap = recall_wrap['dict_wrap']\n topn_wrap = recall_wrap['config']['mt_topn']\n weights = recall_wrap['config']['pos_weights']\n popularity_method_list = recall_wrap['config']['pop_mt_list']\n for news_id in news_ids:\n for mt in popularity_method_list:\n src_item = news_id\n current_prop = dict_id_content[src_item][mt]\n logging.info(\n \"top n {} method with following {}\".format(mt, current_prop))\n single_recall_result = {}\n current_list_with_score = []\n if current_prop[0] != None:\n for prop in current_prop:\n current_list_with_score = current_list_with_score + \\\n self.recall_pos_score(src_item,\n dict_wrap[mt][prop][0:topn_wrap[mt]],\n weights[mt], multiple_shot_record)\n single_recall_result['method'] = mt\n single_recall_result['list'] = current_list_with_score\n logging.info(\"method {} find {} candidates\".format(\n mt, len(current_list_with_score)))\n recall_items.append(single_recall_result)\n\n def recall_by_portrait(self, user_portrait, recall_wrap, recall_items, multiple_shot_record):\n # 根据用户画像做热门召回\n # 1. category: 类别\n # 2. director: 导演\n # 3. actor: 演员\n # 4. language: 语言\n # 5. level: 分级 \n # 6. year: 年限 \n # 7. review: 评论/描述\n # 8. photo: 海报 \n # 9. ub: 用户行为/双塔模型\n dict_wrap = recall_wrap['dict_wrap']\n topn_wrap = recall_wrap['config']['mt_topn']\n weights = recall_wrap['config']['pos_weights']\n portrait_method_list = recall_wrap['config']['portrait_mt_list']\n for mt in portrait_method_list:\n current_prop = user_portrait[mt]\n logging.info(\n \"top n user portrait {} method with following {}\".format(mt, current_prop))\n single_recall_result = {}\n current_list_with_score = []\n if current_prop['recent'] != None:\n user_mt = \"portrait_{}\".format(mt)\n for prop in current_prop['recent'][0]:\n if prop and dict_wrap[mt].get(prop):\n current_list_with_score = current_list_with_score + \\\n self.recall_pos_score(None,\n dict_wrap[mt][prop][0:topn_wrap[user_mt]],\n weights[user_mt], multiple_shot_record)\n else:\n logging.warning(\"cannot find '{}' in dict_wrap[{}]\".format(prop, mt))\n\n single_recall_result['method'] = user_mt\n single_recall_result['list'] = current_list_with_score\n logging.info(\"portrait method {} find {} candidates\".format(\n mt, len(current_list_with_score)))\n recall_items.append(single_recall_result)\n # 根据用户画像做相似性召回\n # 1. ub: 用户行为/YoutubeDNN\n user_ub_embedding = user_portrait['ub_embeddding']\n ub_faiss_index = recall_wrap['ub_index']\n ub_idx_mapping = recall_wrap['ub_idx_mapping']\n D, I = ub_faiss_index.search(np.ascontiguousarray(user_ub_embedding), topn_wrap['portrait_ub'])\n # mapping index code to item code\n single_recall_result = {}\n single_recall_result['method'] = 'portrait_ub'\n single_recall_result['list'] = []\n for d, i in zip(D[0], I[0]):\n map_idx = ub_idx_mapping[i]\n current_idx_with_score = {}\n current_idx_with_score['id'] = map_idx\n current_idx_with_score['score'] = d\n self.analyze_shot_record(multiple_shot_record, map_idx)\n single_recall_result['list'].append(current_idx_with_score)\n recall_items.append(single_recall_result)\n\n def merge_recall_result(self, news_ids, **config_dict):\n ########################################\n # 召回融合排序逻辑\n ########################################\n recall_wrap = config_dict['recall_wrap']\n user_portrait = config_dict['user_portrait']\n\n recall_items = []\n multiple_shot_record = {}\n # 根据最近阅读的历史做召回\n self.recall_by_popularity(news_ids, recall_wrap, recall_items, multiple_shot_record)\n # 根据用户画像做召回\n self.recall_by_portrait(user_portrait, recall_wrap, recall_items, multiple_shot_record)\n\n # recall_merge_cnt = 100\n n_last_len = recall_wrap['config']['merge_cnt']\n method_weights = recall_wrap['config']['mt_weights']\n raw_item_list = {}\n\n for mt_list in recall_items:\n mt = mt_list['method']\n list_result = mt_list['list']\n method_weight = method_weights[mt]\n for idx, id_with_score in enumerate(list_result):\n current_id = id_with_score['id']\n current_score = id_with_score['score']\n multiple_shot_score = multiple_shot_record[current_id]\n whole_score = method_weight * \\\n (current_score + multiple_shot_score)\n current_result = []\n current_result.append(current_id)\n current_result.append(mt)\n current_result.append(idx)\n current_result.append(whole_score)\n # update raw list\n if current_id in raw_item_list.keys():\n if whole_score > raw_item_list[current_id][3]:\n raw_item_list[current_id] = current_result\n else:\n raw_item_list[current_id] = current_result\n\n # 根据最终得分进行排序\n sort_item_list = dict(\n sorted(raw_item_list.items(), key=lambda item: item[1][3], reverse=True))\n\n logging.info(\"sort {} result is {}\".format(\n len(sort_item_list), sort_item_list))\n\n recall_result = {}\n\n # 截取前recall_merge_cnt的结果作为recall的结果\n recall_result = dict(itertools.islice(sort_item_list.items(), n_last_len))\n\n logging.info('Recall has done & return -> {}'.format(recall_result))\n return recall_result\n"
] |
[
[
"numpy.ascontiguousarray"
]
] |
Tubbz-alt/deep_learning_final
|
[
"d187c7125170f56c4744c1ba2bdca948c08fe108"
] |
[
"models.py"
] |
[
"# -*- coding: utf-8 -*-\n\"\"\"Implements SRGAN models: https://arxiv.org/abs/1609.04802\n\nTODO:\n\n\"\"\"\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.autograd import Variable\n\ndef swish(x):\n return x * F.sigmoid(x)\n\nclass FeatureExtractor(nn.Module):\n def __init__(self, cnn, feature_layer=11):\n super(FeatureExtractor, self).__init__()\n self.features = nn.Sequential(*list(cnn.features.children())[:(feature_layer+1)])\n\n def forward(self, x):\n return self.features(x)\n\n\nclass residualBlock(nn.Module):\n def __init__(self, in_channels=64, k=3, n=64, s=1):\n super(residualBlock, self).__init__()\n\n self.conv1 = nn.Conv2d(in_channels, n, k, stride=s, padding=1)\n self.bn1 = nn.BatchNorm2d(n)\n self.conv2 = nn.Conv2d(n, n, k, stride=s, padding=1)\n self.bn2 = nn.BatchNorm2d(n)\n\n def forward(self, x):\n y = swish(self.bn1(self.conv1(x)))\n return self.bn2(self.conv2(y)) + x\n\nclass upsampleBlock(nn.Module):\n # Implements resize-convolution\n def __init__(self, in_channels, out_channels):\n super(upsampleBlock, self).__init__()\n self.conv = nn.Conv2d(in_channels, out_channels, 3, stride=1, padding=1)\n self.shuffler = nn.PixelShuffle(2)\n\n def forward(self, x):\n return swish(self.shuffler(self.conv(x)))\n\nclass Generator(nn.Module):\n def __init__(self, n_residual_blocks, upsample_factor):\n super(Generator, self).__init__()\n self.n_residual_blocks = n_residual_blocks\n self.upsample_factor = upsample_factor\n\n self.conv1 = nn.Conv2d(3, 64, 9, stride=1, padding=4)\n\n for i in range(self.n_residual_blocks):\n self.add_module('residual_block' + str(i+1), residualBlock())\n\n self.conv2 = nn.Conv2d(64, 64, 3, stride=1, padding=1)\n self.bn2 = nn.BatchNorm2d(64)\n\n for i in range(int(self.upsample_factor/2)):\n self.add_module('upsample' + str(i+1), upsampleBlock(64, 256))\n\n self.conv3 = nn.Conv2d(64, 3, 9, stride=1, padding=4)\n\n def forward(self, x):\n x = swish(self.conv1(x))\n\n y = x.clone()\n for i in range(self.n_residual_blocks):\n y = self.__getattr__('residual_block' + str(i+1))(y)\n\n x = self.bn2(self.conv2(y)) + x\n\n for i in range(int(self.upsample_factor/2)):\n x = self.__getattr__('upsample' + str(i+1))(x)\n\n return self.conv3(x)\n\nclass Discriminator(nn.Module):\n def __init__(self):\n super(Discriminator, self).__init__()\n self.conv1 = nn.Conv2d(3, 64, 3, stride=1, padding=1)\n\n self.conv2 = nn.Conv2d(64, 64, 3, stride=2, padding=1)\n self.bn2 = nn.BatchNorm2d(64)\n self.conv3 = nn.Conv2d(64, 128, 3, stride=1, padding=1)\n self.bn3 = nn.BatchNorm2d(128)\n self.conv4 = nn.Conv2d(128, 128, 3, stride=2, padding=1)\n self.bn4 = nn.BatchNorm2d(128)\n self.conv5 = nn.Conv2d(128, 256, 3, stride=1, padding=1)\n self.bn5 = nn.BatchNorm2d(256)\n self.conv6 = nn.Conv2d(256, 256, 3, stride=2, padding=1)\n self.bn6 = nn.BatchNorm2d(256)\n self.conv7 = nn.Conv2d(256, 512, 3, stride=1, padding=1)\n self.bn7 = nn.BatchNorm2d(512)\n self.conv8 = nn.Conv2d(512, 512, 3, stride=2, padding=1)\n self.bn8 = nn.BatchNorm2d(512)\n\n # Replaced original paper FC layers with FCN\n self.conv9 = nn.Conv2d(512, 1, 1, stride=1, padding=1)\n\n def forward(self, x):\n x = swish(self.conv1(x))\n\n x = swish(self.bn2(self.conv2(x)))\n x = swish(self.bn3(self.conv3(x)))\n x = swish(self.bn4(self.conv4(x)))\n x = swish(self.bn5(self.conv5(x)))\n x = swish(self.bn6(self.conv6(x)))\n x = swish(self.bn7(self.conv7(x)))\n x = swish(self.bn8(self.conv8(x)))\n\n x = self.conv9(x)\n return F.sigmoid(F.avg_pool2d(x, x.size()[2:])).view(x.size()[0], -1)\n"
] |
[
[
"torch.nn.PixelShuffle",
"torch.nn.functional.sigmoid",
"torch.nn.Conv2d",
"torch.nn.BatchNorm2d"
]
] |
act65/mri-reconstruction
|
[
"2dcf30e10c37a482f1aab2524c5966d03eb72085"
] |
[
"scripts/train_bernoulliae.py"
] |
[
"import tensorflow as tf\nimport src.bernoulliae as bernoulliae\nimport src.utils as utils\n\nimport os\nimport argparse\n\ndef argumentparser():\n parser = argparse.ArgumentParser(description='Train an SparseAE')\n parser.add_argument('--batch_size', type=int, default=50,\n help='Batch size...')\n parser.add_argument('--epochs', type=int, default=50,\n help='number of epochs')\n parser.add_argument('--logdir', type=str, default='/tmp/sparseae/',\n help='location to save logs')\n parser.add_argument('--n_hidden', type=int, default=12)\n parser.add_argument('--width', type=int, default=16)\n parser.add_argument('--depth', type=int, default=4)\n parser.add_argument('--learning_rate', type=float, default=0.0001)\n parser.add_argument('--beta', type=float, default=1.0)\n return parser.parse_args()\n\ndef main(args):\n from tensorflow.examples.tutorials.mnist import input_data\n mnist = input_data.read_data_sets(\"/tmp/MNIST_data/\", one_hot=True)\n\n PL = utils.PyramidLoss(32, 3)\n\n with tf.variable_scope('s'):\n nn = bernoulliae.BernoulliAE(args.n_hidden, args.width, args.depth)\n\n x = tf.placeholder(shape=[None, 32, 32, 1], dtype=tf.float32)\n recon_loss, prior_loss = nn.make_losses(x)\n pl_loss = PL((x, nn.y))\n loss = pl_loss + recon_loss #+args.beta*prior_loss\n\n train_summaries = [\n tf.summary.scalar('train/loss/recon', recon_loss),\n tf.summary.scalar('train/loss/latent', prior_loss),\n tf.summary.histogram('latents', nn.z),\n tf.summary.image('train/input', x),\n tf.summary.image('train/recon', tf.nn.sigmoid(nn.y)),\n # tf.summary.scalar('train/Px/real', p_real),\n # tf.summary.scalar('train/Px/fake', p_fake)\n ]\n\n p_real = nn.estimate_density(x)\n p_fake = nn.estimate_density(tf.random_normal(shape=tf.shape(x)))\n test_summaries = [\n tf.summary.scalar('test/loss/recon', recon_loss),\n tf.summary.scalar('test/loss/latent', prior_loss),\n tf.summary.image('test/input', x),\n tf.summary.image('test/recon', tf.nn.sigmoid(nn.y)),\n tf.summary.scalar('test/Px/real', tf.reduce_mean(p_real)),\n tf.summary.scalar('test/Px/fake', tf.reduce_mean(p_fake))\n ]\n\n train_merged = tf.summary.merge(train_summaries)\n test_merged = tf.summary.merge(test_summaries)\n\n global_step = tf.train.get_or_create_global_step()\n learning_rate = args.learning_rate\n\n opt = tf.train.AdamOptimizer(learning_rate)\n gnvs = opt.compute_gradients(loss, var_list=nn.encoder.variables+nn.decoder.variables)\n gnvs += opt.compute_gradients(prior_loss, var_list=nn.prior_variables)\n\n # gnvs = [(tf.clip_by_norm(g, 1), v) for g, v in gnvs]\n train_step = opt.apply_gradients(gnvs, global_step=global_step)\n saver = tf.train.Saver()\n checkpoint = tf.contrib.eager.Checkpoint(**{var.name: var for var in tf.global_variables()})\n\n\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n writer = tf.summary.FileWriter(args.logdir, sess.graph)\n\n for i in range(args.epochs*1000):\n batch_x, _ = mnist.train.next_batch(args.batch_size)\n _, train_summ = sess.run([train_step, train_merged],\n feed_dict={x: bernoulliae.BernoulliAE.preprocess(batch_x)})\n\n if i % 10 == 0:\n writer.add_summary(train_summ, i)\n\n if i % 100 == 0:\n L, test_summ = sess.run([loss, test_merged],\n feed_dict={x:\n bernoulliae.BernoulliAE.preprocess(mnist.test.images[:100, ...])})\n print('\\rStep: {} Loss: {}'.format(i, L), end='', flush=True)\n writer.add_summary(test_summ, i)\n\n if i % 1000 == 0:\n save_path = checkpoint.save(os.path.join(args.logdir, \"infovae_ckpt.ckpt\"))\n save_path = saver.save(sess, os.path.join(args.logdir,\"infovae_saver.ckpt\"))\n print(save_path)\n\nif __name__ == '__main__':\n main(argumentparser())\n"
] |
[
[
"tensorflow.summary.merge",
"tensorflow.train.AdamOptimizer",
"tensorflow.summary.image",
"tensorflow.shape",
"tensorflow.summary.scalar",
"tensorflow.summary.histogram",
"tensorflow.examples.tutorials.mnist.input_data.read_data_sets",
"tensorflow.train.Saver",
"tensorflow.Session",
"tensorflow.global_variables",
"tensorflow.variable_scope",
"tensorflow.placeholder",
"tensorflow.train.get_or_create_global_step",
"tensorflow.summary.FileWriter",
"tensorflow.nn.sigmoid",
"tensorflow.reduce_mean",
"tensorflow.global_variables_initializer"
]
] |
MarshallKrakauer/DecisionTree
|
[
"67a0623376a11bc43d94c045519a382b5e46915a"
] |
[
"RandomForest.py"
] |
[
"from collections import defaultdict\nfrom ClassificationTree import ClassificationTree\nfrom RegressionTree import RegressionTree\nfrom MultiClassTree import MultiClassTree\nfrom AbstractDecisionTree import print_breadth_first, get_dataframe, get_multi_class_dataframe\nimport random\nimport numpy as np\n\nclass RandomForest:\n\n def __init__(self, dataframe, y_col='target', target_type='binary', num_trees=3,\n parent=None, depth=0, random_seed=0.0, max_depth=3,\n min_sample_split=0, min_impurity_decrease=float('-inf')):\n if num_trees > 10:\n raise ValueError(\"Max of 10 trees\")\n elif num_trees < 2:\n raise ValueError(\"At least 2 trees required\")\n else:\n self.num_trees = int(num_trees)\n self.df = dataframe\n self.y_col = y_col\n self.depth = depth\n self.max_depth = max_depth\n self.min_sample_split = min_sample_split\n self.min_impurity_decrease = min_impurity_decrease\n self.parent = parent\n self.random_seed = random_seed\n self.tree_list = []\n self.target_type = target_type\n\n def create_trees(self):\n \"\"\"Initialize and fit all the trees in the random forest\"\"\"\n for i in range(self.num_trees):\n # For the first model, use the random seed. We don't want to use that seed for every model\n # Since it will produce identical copies of the first tree\n model = self.make_classifier(is_first=i==0)\n model.create_tree()\n self.tree_list.append(model)\n\n def make_classifier(self, is_first):\n \"\"\"\n Create regression or classification tree.\n\n :param is_first: bool\n True if the first tree in the forest. The first tree uses the random seed, others use a\n randomly generated one\n :return: DecisionTree\n DecisionTree that will be part of \"forest\"\n \"\"\"\n if is_first:\n seed = self.random_seed\n else:\n seed = random.random()\n\n if self.target_type == 'binary':\n model = ClassificationTree(self.df, self.y_col, None, 0, seed,\n self.max_depth, self.min_sample_split, self.min_impurity_decrease)\n elif self.target_type == 'multi_class':\n model = MultiClassTree(self.df, self.y_col, None, 0, seed,\n self.max_depth, self.min_sample_split, self.min_impurity_decrease)\n else:\n model = RegressionTree(self.df, self.y_col, None, 0, seed,\n self.max_depth, self.min_sample_split, self.min_impurity_decrease)\n\n return model\n\n def predict_proba(self, data_row):\n \"\"\"\n Probability prediction for classification models\n\n :param data_row: series\n Row of data from which to make a prediction\n :return: float or dict\n Returns single float value for binary prediction value. For multi class problem,\n returns a dict with probability for each class\n \"\"\"\n if self.target_type == 'continuous':\n raise AttributeError(\"predict_proba not available for regression model\")\n\n if self.target_type == 'binary':\n prediction_list = []\n for decision_tree in self.tree_list:\n percentage = decision_tree.predict_proba(data_row)\n prediction_list.append(percentage)\n\n return np.mean(prediction_list)\n\n elif self.target_type == 'multi_class':\n def default_dict_zero():\n return 0\n predict_dict = defaultdict(default_dict_zero)\n for decision_tree in self.tree_list:\n output_dict = decision_tree.predict_proba(data_row)\n for key, percent in output_dict.items():\n predict_dict[key] += percent / self.num_trees\n\n return dict(predict_dict)\n\n def predict(self, data_row, cutoff=0.5):\n \"\"\"\n Get predicted value for regression, or predicted class for classification\n\n :param data_row: series\n Row of data from which to make a prediction\n :param cutoff: int\n Cutoff value for binary prediction. If above or equal to this value, will predict 1. If below,\n predicts 0. Not used in multi class or regression\n :return: float or int\n Single value of the most likely class (with classification). For regression, produces predicted value.\n \"\"\"\n if self.target_type == 'binary':\n if self.predict_proba(data_row) >= cutoff:\n return 1\n else:\n return 0\n\n elif self.target_type == 'continuous':\n prediction_list = []\n\n for decision_tree in self.tree_list:\n percentage = decision_tree.predict(data_row)\n prediction_list.append(percentage)\n\n return np.mean(prediction_list)\n\n else:\n prediction_dict = self.predict_proba(data_row)\n max_value = float('-inf')\n best_prediction = None\n for key, current_value in prediction_dict.items():\n if prediction_dict[key] > max_value:\n max_value = current_value\n best_prediction = key\n\n return best_prediction\n\nif __name__ == '__main__':\n # Select type of trees: binary, multi_class, or continuous (ie regression)\n prediction_type = 'multi_class'\n print_trees = False\n\n # Different dataframe creation functions for multi_class and binary/continuous\n if prediction_type == 'multi_class':\n df, individual_val, true_value = get_multi_class_dataframe() # get_dataframe(is_classification)\n else:\n df, individual_val, true_value = get_dataframe(prediction_type == 'binary')\n\n rf = RandomForest(dataframe=df, y_col='y',target_type=prediction_type,\n max_depth=3, num_trees=3, random_seed=777, min_impurity_decrease=0.4)\n rf.create_trees()\n\n if print_trees:\n for idx, tree in enumerate(rf.tree_list):\n print('~~~TREE NUMBER {}~~~'.format(idx+1))\n print_breadth_first(tree)\n\n # For classification trees we can print out predicted value and class\n # For regression trees, we only have a predicted value\n if prediction_type in ['binary','multi_class']:\n prob = rf.predict_proba(individual_val)\n class_ = rf.predict(individual_val)\n\n # We have a specific value we can round for binary predictions\n # For multiclass one, we have the entire dictionary\n if prediction_type == 'binary':\n print('predicted:', np.round(prob, 3),',', class_, 'actual:', true_value)\n else:\n print('predicted:', prob , ',', class_, 'actual:', true_value)\n else:\n value = rf.predict(individual_val)\n print('predicted:', np.round(value, 3), 'actual:', true_value)"
] |
[
[
"numpy.round",
"numpy.mean"
]
] |
stopyun-jirong/igrf
|
[
"951ad3414b2b89e0121faec02e3e194b0e745428"
] |
[
"src/igrf/base.py"
] |
[
"import xarray\nfrom datetime import datetime\nimport numpy as np\nimport subprocess\nimport shutil\nimport os\nfrom pathlib import Path\nimport importlib.resources\n\nfrom .utils import mag_vector2incl_decl, datetime2yeardec\n\n\ndef cmake(setup_file: Path):\n \"\"\"\n attempt to build using CMake\n \"\"\"\n exe = shutil.which(\"ctest\")\n if not exe:\n raise FileNotFoundError(\"CMake not available\")\n\n subprocess.check_call([exe, \"-S\", str(setup_file), \"-VV\"])\n\n\ndef build_exe(exe_name: str) -> str:\n # build on run\n if os.name == \"nt\":\n exe_name += \".exe\"\n if not importlib.resources.is_resource(__package__, exe_name):\n with importlib.resources.path(__package__, \"setup.cmake\") as setup_file:\n cmake(setup_file)\n if not importlib.resources.is_resource(__package__, exe_name):\n raise ModuleNotFoundError(\"could not build MSISE00 Fortran driver\")\n\n return exe_name\n\n\ndef grid(\n time: datetime,\n glat: np.ndarray,\n glon: np.ndarray,\n alt_km: np.ndarray,\n *,\n isv: int = 0,\n itype: int = 1,\n) -> xarray.Dataset:\n\n glat = np.atleast_1d(glat)\n glon = np.atleast_1d(glon)\n\n yeardec = datetime2yeardec(time)\n\n x = np.empty(glat.size)\n y = np.empty_like(x)\n z = np.empty_like(x)\n f = np.empty_like(x)\n\n with importlib.resources.path(__package__, build_exe(\"igrf13_driver\")) as exe:\n for i, (la, lo) in enumerate(zip(glat.ravel(), glon.ravel())):\n cmd = [str(exe), str(yeardec), str(la), str(lo), str(alt_km), str(isv), str(itype)]\n ret = subprocess.run(\n cmd, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE\n )\n if ret.returncode != 0:\n raise RuntimeError(\n f\"IGRF13 error code {ret.returncode}\\n{ret.stderr}\\n{' '.join(cmd)}\"\n )\n # different compilers throw in extra \\n\n x[i], y[i], z[i], f[i] = list(map(float, ret.stdout.split()))\n\n # %% assemble output\n if glat.ndim == 2 and glon.ndim == 2: # assume meshgrid\n coords = {\"glat\": glat[:, 0], \"glon\": glon[0, :]}\n elif glat.ndim == 1 and glon.ndim == 1:\n coords = {\"glat\": glat, \"glon\": glon}\n else:\n raise ValueError(f\"glat/glon shapes: {glat.shape} {glon.shape}\")\n\n mag = xarray.Dataset(coords=coords, attrs={\"time\": time, \"isv\": isv, \"itype\": itype})\n mag[\"north\"] = ((\"glat\", \"glon\"), x.reshape(glat.shape))\n mag[\"east\"] = ((\"glat\", \"glon\"), y.reshape(glat.shape))\n mag[\"down\"] = ((\"glat\", \"glon\"), z.reshape(glat.shape))\n mag[\"total\"] = ((\"glat\", \"glon\"), f.reshape(glat.shape))\n\n decl, incl = mag_vector2incl_decl(mag.north, mag.east, mag.down)\n\n mag[\"incl\"] = ((\"glat\", \"glon\"), incl)\n mag[\"decl\"] = ((\"glat\", \"glon\"), decl)\n\n return mag\n\n\ndef igrf(\n time: datetime, glat: float, glon: float, alt_km: np.ndarray, *, isv: int = 0, itype: int = 1,\n) -> xarray.Dataset:\n \"\"\"\n\n Parameters\n ----------\n\n date: datetime.date or decimal year yyyy.dddd\n glat, glon: geographic Latitude, Longitude\n alt_km: altitude [km] above sea level for itype==1\n isv: 0 for main geomagnetic field\n itype: 1: altitude is above sea level\n \"\"\"\n\n # decimal year\n yeardec = datetime2yeardec(time)\n\n alt_km = np.atleast_1d(alt_km)\n Bnorth = np.empty(alt_km.size)\n Beast = np.empty_like(Bnorth)\n Bvert = np.empty_like(Bnorth)\n Btotal = np.empty_like(Bnorth)\n\n with importlib.resources.path(__package__, build_exe(\"igrf13_driver\")) as exe:\n for i, a in enumerate(alt_km):\n cmd = [str(exe), str(yeardec), str(glat), str(glon), str(a), str(isv), str(itype)]\n ret = subprocess.run(\n cmd, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE\n )\n if ret.returncode != 0:\n raise RuntimeError(\n f\"IGRF13 error code {ret.returncode}\\n{ret.stderr}\\n{' '.join(cmd)}\"\n )\n # different compilers throw in extra \\n\n\n Bnorth[i], Beast[i], Bvert[i], Btotal[i] = list(map(float, ret.stdout.split()))\n\n # %% assemble output\n decl, incl = mag_vector2incl_decl(Bnorth, Beast, Bvert)\n\n mag = xarray.Dataset(\n {\n \"north\": (\"alt_km\", Bnorth),\n \"east\": (\"alt_km\", Beast),\n \"down\": (\"alt_km\", Bvert),\n \"total\": (\"alt_km\", Btotal),\n \"incl\": (\"alt_km\", incl),\n \"decl\": (\"alt_km\", decl),\n },\n coords={\"alt_km\": alt_km},\n attrs={\"time\": time, \"isv\": isv, \"itype\": itype, \"glat\": glat, \"glon\": glon},\n )\n\n\n return mag\n"
] |
[
[
"numpy.empty_like",
"numpy.atleast_1d",
"numpy.empty"
]
] |
CRIPAC-DIG/K-GHRM
|
[
"5d73ed701b7753ee402ecfc1dbc4b20c578a4656"
] |
[
"Data/ent2vec.py"
] |
[
"from wikipedia2vec import Wikipedia2Vec\nimport pickle\nimport numpy as np\nimport argparse\n\nparser = argparse.ArgumentParser()\nparser.add_argument('--dataset', default='robust04', help='dataset name: robust04/clueweb09')\nargs = parser.parse_args()\n\ndef save_obj(obj, name):\n with open(name + '.pkl', 'wb') as f:\n pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)\n\ndef load_obj(name):\n with open(name + '.pkl', 'rb') as f:\n return pickle.load(f)\n\nwiki2vec = Wikipedia2Vec.load('./enwiki_20180420_100d.pkl')\n# wiki2vec = Wikipedia2Vec.load('./enwiki_20180420_300d.pkl')\nent2id = load_obj('./{}/ent2id'.format(args.dataset))\n\nent2vec = []\nno_pretrain_emd_cnt = 0 \nfor e in ent2id:\n try:\n ent2vec.append(wiki2vec.get_entity_vector(e))\n except:\n no_pretrain_emd_cnt += 1\n ent2vec.append(np.random.randn(100))\n # ent2vec.append(np.random.randn(300))\nprint(no_pretrain_emd_cnt) # clueweb09:22820, robust04:8423\nprint(len(ent2vec)) # clueweb09:226363, robust04:108627\nnp.save('./{}/ent_embedding_100d.npy'.format(args.dataset), ent2vec)\n# np.save('./{}/ent_embedding_300d.npy'.format(args.dataset), ent2vec)\n\n# que_ent = load_obj('./{}/que_entity'.format(args.dataset))\n# with open('./{}/que_entity_list_unique.txt'.format(args.dataset), 'w') as f:\n# for i in que_ent:\n# f.writelines(str(i)+'\\t')\n# for word in que_ent[i]:\n# f.writelines(str(ent2id[word])+' ')\n# f.writelines('\\n')\n"
] |
[
[
"numpy.random.randn"
]
] |
FloydHsiu/Multi-focus-Image-Fusion-Using-Encoder-Decoder-Network
|
[
"996583e1db60ff1f7e8fc9383e0f0785773f2f54"
] |
[
"train.py"
] |
[
"import tensorflow as tf\nfrom data import parseDataset\nimport model\nimport datetime\nfrom os import path\nimport tqdm\nimport argparse\n\n\n@tf.function(experimental_relax_shapes=True)\ndef convertData(A, B, label):\n A = A / 255.0\n B = B / 255.0\n A = A * 2.0 - 1.0\n B = B * 2.0 - 1.0\n label = label * 2.0 - 1.0\n return A, B, label\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(description='')\n parser.add_argument(\n '--tpu_name', dest='tpu_name', type=str, default='',\n help='Assign tpu that you want to train this code on')\n parser.add_argument(\n '--data_path', type=str, default='',\n help='Assign your training data (tfrecords)')\n parser.add_argument(\n '--logs_dir', tpye=str, default='',\n help='Assisn your directory to keep training logs')\n parser.add_argument(\n '--lytro_dir', type=str, default='',\n help='Assign directory of Lytro Multi-focus Dataset')\n\n args = parser.parse_args()\n\n if parser.tpu_name == '':\n print('Error: have no tpu_name been declared.')\n return\n if parser.data_path == '':\n print('Error: have no training data path been declared.')\n return\n if parser.logs_dir == '':\n print('Error: have no training logs directory been declared')\n return\n if parser.lytro_dir == '':\n print('Error: have no lytro multi-focus dataset directory been declared')\n\n batch_size = 128\n learning_rate = 1e-4\n learning_rate_decay = 1e-1\n epoch = 2\n\n TPU_NAME = parser.tpu_name\n DATA_PATH = parser.data_path\n LOGS_DIR = parser.logs_dir\n LYTRO_DIR = parser.lytro_dir\n\n # TPU distributed computation initialization\n cluster_resolver = tf.distribute.cluster_resolver.TPUClusterResolver(\n tpu=TPU_NAME)\n tf.config.experimental_connect_to_cluster(cluster_resolver)\n tf.tpu.experimental.initialize_tpu_system(cluster_resolver)\n tpu_strategy = tf.distribute.experimental.TPUStrategy(cluster_resolver)\n\n ############### DATAs ###############\n # split training data and valiation data\n dataset = tf.data.TFRecordDataset(DATA_PATH)\n dataset = dataset.map(parseDataset).shuffle(\n buffer_size=10000, reshuffle_each_iteration=False)\n\n train_dataset = dataset.take(90000).batch(batch_size, drop_remainder=False)\n test_dataset = dataset.skip(90000).batch(batch_size, drop_remainder=False)\n\n train_dist_dataset = tpu_strategy.experimental_distribute_dataset(\n train_dataset)\n test_dist_dataset = tpu_strategy.experimental_distribute_dataset(\n test_dataset)\n\n with tpu_strategy.scope():\n mfnet = model.MFNet()\n\n ############### LOGs ###############\n dt_now = datetime.datetime.now().strftime(\"%Y%m%d_%H%M%S\")\n print(f\"############ {dt_now} ############\")\n tensorboard_log_dir = path.join(LOGS_DIR, 'fcn_origin_'+dt_now)\n\n # checkpoint initialize\n checkpoint_dir = path.join(tensorboard_log_dir, 'training_checkpoints')\n makedirs(checkpoint_dir, exist_ok=True)\n checkpoint_prefix = path.join(checkpoint_dir, \"ckpt\")\n checkpoint = tf.train.Checkpoint(mfnet=mfnet)\n ckpt_manager = tf.train.CheckpointManager(\n checkpoint, directory=checkpoint_dir, max_to_keep=5)\n\n # Model directory initialize\n model_dir = path.join(tensorboard_log_dir, 'model')\n\n # tensorboard initialize\n tensorboard_dir = path.join(tensorboard_log_dir, 'tensorboard')\n makedirs(tensorboard_dir, exist_ok=True)\n summary_writer = tf.summary.create_file_writer(tensorboard_dir)\n\n # Read Images for Inference\n fns = [\"lytro-03-A.jpg\", \"lytro-03-B.jpg\",\n \"lytro-05-A.jpg\", \"lytro-05-B.jpg\"]\n paths = [path.join(LYTRO_DIR, fn) for fn in fns]\n\n imgs = []\n for i in range(0, len(paths), 2):\n tmp1 = tf.io.read_file(paths[i])\n tmp2 = tf.io.read_file(paths[i+1])\n img1 = tf.cast(\n tf.io.decode_jpeg(tmp1, channels=1),\n tf.float32) / 255.0 * 2.0 - 1\n img2 = tf.cast(\n tf.io.decode_jpeg(tmp2, channels=1),\n tf.float32) / 255.0 * 2.0 - 1\n img1 = tf.reshape(img1, (1, 520, 520, 1))\n img2 = tf.reshape(img2, (1, 520, 520, 1))\n img1 = tf.slice(img1, [0, 0, 0, 0], [1, 512, 512, 1])\n img2 = tf.slice(img2, [0, 0, 0, 0], [1, 512, 512, 1])\n imgs.append([img1, img2])\n\n # stage 1\n with tpu_strategy.scope():\n optimizer_1 = tf.optimizers.Adam(\n learning_rate=learning_rate, beta_1=0.5)\n optimizer_2 = tf.optimizers.Adam(\n learning_rate=learning_rate*learning_rate_decay, beta_1=0.5)\n\n @tf.function\n def validation(dist_inputs):\n def step_fn(inputs):\n p1 = inputs['p1']\n p2 = inputs['p2']\n label = inputs['label']\n p1, p2, label = convertData(p1, p2, label)\n pred = mfnet([p1, p2], training=False)\n loss_fn = tf.keras.losses.Huber(\n delta=0.2, reduction=tf.keras.losses.Reduction.NONE)\n mae = loss_fn(label, pred)\n loss = tf.reduce_sum(mae, keepdims=True) / (320 * 320)\n return loss\n per_example_losses = tpu_strategy.experimental_run_v2(\n step_fn, args=(dist_inputs,))\n mean_loss = tpu_strategy.reduce(\n tf.distribute.ReduceOp.SUM, per_example_losses, axis=0)\n\n return mean_loss\n\n @tf.function\n def train_step_1(dist_inputs):\n # In training step 1, learning rate is set as 1e-4\n def step_fn(inputs):\n p1 = inputs['p1']\n p2 = inputs['p2']\n label = inputs['label']\n p1, p2, label = convertData(p1, p2, label)\n with tf.GradientTape() as g_tape:\n pred = mfnet([p1, p2], training=True)\n loss_fn = tf.keras.losses.Huber(\n delta=0.2, reduction=tf.keras.losses.Reduction.NONE)\n mae = loss_fn(label, pred)\n loss = tf.reduce_sum(\n mae, keepdims=True) / (batch_size * 320 * 320)\n grad = g_tape.gradient(loss, mfnet.trainable_variables)\n optimizer_1.apply_gradients(\n list(zip(grad, mfnet.trainable_variables)))\n return loss\n per_example_losses = tpu_strategy.experimental_run_v2(\n step_fn, args=(dist_inputs,))\n mean_loss = tpu_strategy.reduce(\n tf.distribute.ReduceOp.SUM, per_example_losses, axis=0)\n\n return mean_loss\n\n @tf.function\n def train_step_2(dist_inputs):\n # In training step 1, learning rate is set as 1e-4 * 1e-1\n def step_fn(inputs):\n p1 = inputs['p1']\n p2 = inputs['p2']\n label = inputs['label']\n p1, p2, label = convertData(p1, p2, label)\n with tf.GradientTape() as g_tape:\n pred = mfnet([p1, p2], training=True)\n loss_fn = tf.keras.losses.Huber(\n delta=0.2, reduction=tf.keras.losses.Reduction.NONE)\n mae = loss_fn(label, pred)\n loss = tf.reduce_sum(\n mae, keepdims=True) / (batch_size * 320 * 320)\n grad = g_tape.gradient(loss, mfnet.trainable_variables)\n optimizer_2.apply_gradients(\n list(zip(grad, mfnet.trainable_variables)))\n return loss\n per_example_losses = tpu_strategy.experimental_run_v2(\n step_fn, args=(dist_inputs,))\n mean_loss = tpu_strategy.reduce(\n tf.distribute.ReduceOp.SUM, per_example_losses, axis=0)\n\n return mean_loss\n\n @tf.function\n def inference():\n result = []\n for i_s in imgs:\n img1 = i_s[0]\n img2 = i_s[1]\n alpha = mfnet([img1, img2], training=False)\n alpha = (alpha+1.0)/2.0\n result.append(alpha)\n return result\n\n train_step = train_step_1\n\n i = 0\n for e in range(epoch):\n if e == epoch//2:\n train_step = train_step_2\n for inputs in tqdm.tqdm(train_dist_dataset):\n with tpu_strategy.scope():\n loss = train_step(inputs)\n\n if i % 1000 == 0:\n checkpoint.save(file_prefix=checkpoint_prefix)\n if i % 100 == 0:\n total_loss = 0.0\n count = 10000\n for inputs_val in test_dist_dataset:\n with tpu_strategy.scope():\n val_loss = tf.squeeze(validation(inputs_val))\n total_loss += val_loss\n with summary_writer.as_default():\n tf.summary.scalar('val', total_loss/count, step=i)\n result = inference()\n for j in range(len(result)):\n tf.summary.image(\n f\"Test Image {j+1}\", result[j],\n step=i)\n with summary_writer.as_default():\n tf.summary.scalar('loss', tf.squeeze(loss), step=i)\n i = i + 1\n tf.saved_model.save(mfnet, model_dir)\n tf.saved_model.save(mfnet, model_dir)\n checkpoint.save(file_prefix=checkpoint_prefix)\n"
] |
[
[
"tensorflow.data.TFRecordDataset",
"tensorflow.io.read_file",
"tensorflow.function",
"tensorflow.reshape",
"tensorflow.saved_model.save",
"tensorflow.GradientTape",
"tensorflow.train.CheckpointManager",
"tensorflow.config.experimental_connect_to_cluster",
"tensorflow.distribute.cluster_resolver.TPUClusterResolver",
"tensorflow.squeeze",
"tensorflow.keras.losses.Huber",
"tensorflow.summary.scalar",
"tensorflow.summary.create_file_writer",
"tensorflow.reduce_sum",
"tensorflow.distribute.experimental.TPUStrategy",
"tensorflow.train.Checkpoint",
"tensorflow.io.decode_jpeg",
"tensorflow.summary.image",
"tensorflow.optimizers.Adam",
"tensorflow.slice",
"tensorflow.tpu.experimental.initialize_tpu_system"
]
] |
William-prog/airflow
|
[
"b2e3e8c0718142d4cb0387f46cd77c15b67cc1e9"
] |
[
"tests/core.py"
] |
[
"# -*- coding: utf-8 -*-\n#\n# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\nfrom typing import Optional\nimport io\nimport json\nimport multiprocessing\nimport os\nimport pickle # type: ignore\nimport re\nimport signal\nimport subprocess\nimport tempfile\nimport unittest\nimport warnings\nfrom datetime import timedelta\nfrom email.mime.application import MIMEApplication\nfrom email.mime.multipart import MIMEMultipart\nfrom email.mime.text import MIMEText\nfrom tempfile import NamedTemporaryFile\nfrom time import sleep\nfrom unittest import mock\n\nimport sqlalchemy\nfrom dateutil.relativedelta import relativedelta\nfrom numpy.testing import assert_array_almost_equal\nfrom pendulum import utcnow\n\nfrom airflow import configuration, models\nfrom airflow import jobs, DAG, utils, settings, exceptions\nfrom airflow.bin import cli\nfrom airflow.configuration import AirflowConfigException, run_command, conf\nfrom airflow.exceptions import AirflowException\nfrom airflow.executors import SequentialExecutor\nfrom airflow.hooks.base_hook import BaseHook\nfrom airflow.hooks.sqlite_hook import SqliteHook\nfrom airflow.models import (\n BaseOperator,\n Connection,\n TaskFail,\n DagBag,\n DagRun,\n Pool,\n DagModel,\n TaskInstance,\n Variable,\n)\nfrom airflow.operators.bash_operator import BashOperator\nfrom airflow.operators.check_operator import CheckOperator, ValueCheckOperator\nfrom airflow.operators.dagrun_operator import TriggerDagRunOperator\nfrom airflow.operators.dummy_operator import DummyOperator\nfrom airflow.operators.python_operator import PythonOperator\nfrom airflow.settings import Session\nfrom airflow.utils import timezone\nfrom airflow.utils.dates import (\n days_ago, infer_time_unit, round_time,\n scale_time_units\n)\nfrom airflow.utils.state import State\nfrom airflow.utils.timezone import datetime\nfrom airflow.hooks import hdfs_hook\nfrom tests.test_utils.config import conf_vars\n\nDEV_NULL = '/dev/null'\nTEST_DAG_FOLDER = os.path.join(\n os.path.dirname(os.path.realpath(__file__)), 'dags')\nDEFAULT_DATE = datetime(2015, 1, 1)\nDEFAULT_DATE_ISO = DEFAULT_DATE.isoformat()\nDEFAULT_DATE_DS = DEFAULT_DATE_ISO[:10]\nTEST_DAG_ID = 'unit_tests'\nEXAMPLE_DAG_DEFAULT_DATE = days_ago(2)\n\n\nclass OperatorSubclass(BaseOperator):\n \"\"\"\n An operator to test template substitution\n \"\"\"\n template_fields = ['some_templated_field']\n\n def __init__(self, some_templated_field, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.some_templated_field = some_templated_field\n\n def execute(self, context):\n pass\n\n\nclass TestCore(unittest.TestCase):\n TEST_SCHEDULE_WITH_NO_PREVIOUS_RUNS_DAG_ID = TEST_DAG_ID + 'test_schedule_dag_no_previous_runs'\n TEST_SCHEDULE_DAG_FAKE_SCHEDULED_PREVIOUS_DAG_ID = \\\n TEST_DAG_ID + 'test_schedule_dag_fake_scheduled_previous'\n TEST_SCHEDULE_DAG_NO_END_DATE_UP_TO_TODAY_ONLY_DAG_ID = \\\n TEST_DAG_ID + 'test_schedule_dag_no_end_date_up_to_today_only'\n TEST_SCHEDULE_ONCE_DAG_ID = TEST_DAG_ID + 'test_schedule_dag_once'\n TEST_SCHEDULE_RELATIVEDELTA_DAG_ID = TEST_DAG_ID + 'test_schedule_dag_relativedelta'\n TEST_SCHEDULE_START_END_DATES_DAG_ID = TEST_DAG_ID + 'test_schedule_dag_start_end_dates'\n\n default_scheduler_args = {\"num_runs\": 1}\n\n def setUp(self):\n self.dagbag = DagBag(\n dag_folder=DEV_NULL, include_examples=True)\n self.args = {'owner': 'airflow', 'start_date': DEFAULT_DATE}\n self.dag = DAG(TEST_DAG_ID, default_args=self.args)\n self.dag_bash = self.dagbag.dags['example_bash_operator']\n self.runme_0 = self.dag_bash.get_task('runme_0')\n self.run_after_loop = self.dag_bash.get_task('run_after_loop')\n self.run_this_last = self.dag_bash.get_task('run_this_last')\n\n def tearDown(self):\n if os.environ.get('KUBERNETES_VERSION') is not None:\n return\n\n dag_ids_to_clean = [\n TEST_DAG_ID,\n self.TEST_SCHEDULE_WITH_NO_PREVIOUS_RUNS_DAG_ID,\n self.TEST_SCHEDULE_DAG_FAKE_SCHEDULED_PREVIOUS_DAG_ID,\n self.TEST_SCHEDULE_DAG_NO_END_DATE_UP_TO_TODAY_ONLY_DAG_ID,\n self.TEST_SCHEDULE_ONCE_DAG_ID,\n self.TEST_SCHEDULE_RELATIVEDELTA_DAG_ID,\n self.TEST_SCHEDULE_START_END_DATES_DAG_ID,\n ]\n session = Session()\n session.query(DagRun).filter(\n DagRun.dag_id.in_(dag_ids_to_clean)).delete(\n synchronize_session=False)\n session.query(TaskInstance).filter(\n TaskInstance.dag_id.in_(dag_ids_to_clean)).delete(\n synchronize_session=False)\n session.query(TaskFail).filter(\n TaskFail.dag_id.in_(dag_ids_to_clean)).delete(\n synchronize_session=False)\n session.commit()\n session.close()\n\n def test_schedule_dag_no_previous_runs(self):\n \"\"\"\n Tests scheduling a dag with no previous runs\n \"\"\"\n dag = DAG(self.TEST_SCHEDULE_WITH_NO_PREVIOUS_RUNS_DAG_ID)\n dag.add_task(BaseOperator(\n task_id=\"faketastic\",\n owner='Also fake',\n start_date=datetime(2015, 1, 2, 0, 0)))\n\n dag_run = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)\n self.assertIsNotNone(dag_run)\n self.assertEqual(dag.dag_id, dag_run.dag_id)\n self.assertIsNotNone(dag_run.run_id)\n self.assertNotEqual('', dag_run.run_id)\n self.assertEqual(\n datetime(2015, 1, 2, 0, 0),\n dag_run.execution_date,\n msg='dag_run.execution_date did not match expectation: {0}'\n .format(dag_run.execution_date)\n )\n self.assertEqual(State.RUNNING, dag_run.state)\n self.assertFalse(dag_run.external_trigger)\n dag.clear()\n\n def test_schedule_dag_relativedelta(self):\n \"\"\"\n Tests scheduling a dag with a relativedelta schedule_interval\n \"\"\"\n delta = relativedelta(hours=+1)\n dag = DAG(self.TEST_SCHEDULE_RELATIVEDELTA_DAG_ID,\n schedule_interval=delta)\n dag.add_task(BaseOperator(\n task_id=\"faketastic\",\n owner='Also fake',\n start_date=datetime(2015, 1, 2, 0, 0)))\n\n dag_run = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)\n self.assertIsNotNone(dag_run)\n self.assertEqual(dag.dag_id, dag_run.dag_id)\n self.assertIsNotNone(dag_run.run_id)\n self.assertNotEqual('', dag_run.run_id)\n self.assertEqual(\n datetime(2015, 1, 2, 0, 0),\n dag_run.execution_date,\n msg='dag_run.execution_date did not match expectation: {0}'\n .format(dag_run.execution_date)\n )\n self.assertEqual(State.RUNNING, dag_run.state)\n self.assertFalse(dag_run.external_trigger)\n dag_run2 = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)\n self.assertIsNotNone(dag_run2)\n self.assertEqual(dag.dag_id, dag_run2.dag_id)\n self.assertIsNotNone(dag_run2.run_id)\n self.assertNotEqual('', dag_run2.run_id)\n self.assertEqual(\n datetime(2015, 1, 2, 0, 0) + delta,\n dag_run2.execution_date,\n msg='dag_run2.execution_date did not match expectation: {0}'\n .format(dag_run2.execution_date)\n )\n self.assertEqual(State.RUNNING, dag_run2.state)\n self.assertFalse(dag_run2.external_trigger)\n dag.clear()\n\n def test_schedule_dag_fake_scheduled_previous(self):\n \"\"\"\n Test scheduling a dag where there is a prior DagRun\n which has the same run_id as the next run should have\n \"\"\"\n delta = timedelta(hours=1)\n\n dag = DAG(self.TEST_SCHEDULE_DAG_FAKE_SCHEDULED_PREVIOUS_DAG_ID,\n schedule_interval=delta,\n start_date=DEFAULT_DATE)\n dag.add_task(BaseOperator(\n task_id=\"faketastic\",\n owner='Also fake',\n start_date=DEFAULT_DATE))\n\n scheduler = jobs.SchedulerJob(**self.default_scheduler_args)\n dag.create_dagrun(run_id=DagRun.id_for_date(DEFAULT_DATE),\n execution_date=DEFAULT_DATE,\n state=State.SUCCESS,\n external_trigger=True)\n dag_run = scheduler.create_dag_run(dag)\n self.assertIsNotNone(dag_run)\n self.assertEqual(dag.dag_id, dag_run.dag_id)\n self.assertIsNotNone(dag_run.run_id)\n self.assertNotEqual('', dag_run.run_id)\n self.assertEqual(\n DEFAULT_DATE + delta,\n dag_run.execution_date,\n msg='dag_run.execution_date did not match expectation: {0}'\n .format(dag_run.execution_date)\n )\n self.assertEqual(State.RUNNING, dag_run.state)\n self.assertFalse(dag_run.external_trigger)\n\n def test_schedule_dag_once(self):\n \"\"\"\n Tests scheduling a dag scheduled for @once - should be scheduled the first time\n it is called, and not scheduled the second.\n \"\"\"\n dag = DAG(self.TEST_SCHEDULE_ONCE_DAG_ID)\n dag.schedule_interval = '@once'\n dag.add_task(BaseOperator(\n task_id=\"faketastic\",\n owner='Also fake',\n start_date=datetime(2015, 1, 2, 0, 0)))\n dag_run = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)\n dag_run2 = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)\n\n self.assertIsNotNone(dag_run)\n self.assertIsNone(dag_run2)\n dag.clear()\n\n def test_fractional_seconds(self):\n \"\"\"\n Tests if fractional seconds are stored in the database\n \"\"\"\n dag = DAG(TEST_DAG_ID + 'test_fractional_seconds')\n dag.schedule_interval = '@once'\n dag.add_task(BaseOperator(\n task_id=\"faketastic\",\n owner='Also fake',\n start_date=datetime(2015, 1, 2, 0, 0)))\n\n start_date = timezone.utcnow()\n\n run = dag.create_dagrun(\n run_id='test_' + start_date.isoformat(),\n execution_date=start_date,\n start_date=start_date,\n state=State.RUNNING,\n external_trigger=False\n )\n\n run.refresh_from_db()\n\n self.assertEqual(start_date, run.execution_date,\n \"dag run execution_date loses precision\")\n self.assertEqual(start_date, run.start_date,\n \"dag run start_date loses precision \")\n\n def test_schedule_dag_start_end_dates(self):\n \"\"\"\n Tests that an attempt to schedule a task after the Dag's end_date\n does not succeed.\n \"\"\"\n delta = timedelta(hours=1)\n runs = 3\n start_date = DEFAULT_DATE\n end_date = start_date + (runs - 1) * delta\n\n dag = DAG(self.TEST_SCHEDULE_START_END_DATES_DAG_ID,\n start_date=start_date,\n end_date=end_date,\n schedule_interval=delta)\n dag.add_task(BaseOperator(task_id='faketastic', owner='Also fake'))\n\n # Create and schedule the dag runs\n dag_runs = []\n scheduler = jobs.SchedulerJob(**self.default_scheduler_args)\n for _ in range(runs):\n dag_runs.append(scheduler.create_dag_run(dag))\n\n additional_dag_run = scheduler.create_dag_run(dag)\n\n for dag_run in dag_runs:\n self.assertIsNotNone(dag_run)\n\n self.assertIsNone(additional_dag_run)\n\n def test_schedule_dag_no_end_date_up_to_today_only(self):\n \"\"\"\n Tests that a Dag created without an end_date can only be scheduled up\n to and including the current datetime.\n\n For example, if today is 2016-01-01 and we are scheduling from a\n start_date of 2015-01-01, only jobs up to, but not including\n 2016-01-01 should be scheduled.\n \"\"\"\n session = settings.Session()\n delta = timedelta(days=1)\n now = utcnow()\n start_date = now.subtract(weeks=1)\n\n runs = (now - start_date).days\n\n dag = DAG(self.TEST_SCHEDULE_DAG_NO_END_DATE_UP_TO_TODAY_ONLY_DAG_ID,\n start_date=start_date,\n schedule_interval=delta)\n dag.add_task(BaseOperator(task_id='faketastic', owner='Also fake'))\n\n dag_runs = []\n scheduler = jobs.SchedulerJob(**self.default_scheduler_args)\n for _ in range(runs):\n dag_run = scheduler.create_dag_run(dag)\n dag_runs.append(dag_run)\n\n # Mark the DagRun as complete\n dag_run.state = State.SUCCESS\n session.merge(dag_run)\n session.commit()\n\n # Attempt to schedule an additional dag run (for 2016-01-01)\n additional_dag_run = scheduler.create_dag_run(dag)\n\n for dag_run in dag_runs:\n self.assertIsNotNone(dag_run)\n\n self.assertIsNone(additional_dag_run)\n\n def test_confirm_unittest_mod(self):\n self.assertTrue(conf.get('core', 'unit_test_mode'))\n\n def test_pickling(self):\n dp = self.dag.pickle()\n self.assertEqual(dp.pickle.dag_id, self.dag.dag_id)\n\n def test_rich_comparison_ops(self):\n\n class DAGsubclass(DAG):\n pass\n\n dag_eq = DAG(TEST_DAG_ID, default_args=self.args)\n\n dag_diff_load_time = DAG(TEST_DAG_ID, default_args=self.args)\n dag_diff_name = DAG(TEST_DAG_ID + '_neq', default_args=self.args)\n\n dag_subclass = DAGsubclass(TEST_DAG_ID, default_args=self.args)\n dag_subclass_diff_name = DAGsubclass(\n TEST_DAG_ID + '2', default_args=self.args)\n\n for d in [dag_eq, dag_diff_name, dag_subclass, dag_subclass_diff_name]:\n d.last_loaded = self.dag.last_loaded\n\n # test identity equality\n self.assertEqual(self.dag, self.dag)\n\n # test dag (in)equality based on _comps\n self.assertEqual(dag_eq, self.dag)\n self.assertNotEqual(dag_diff_name, self.dag)\n self.assertNotEqual(dag_diff_load_time, self.dag)\n\n # test dag inequality based on type even if _comps happen to match\n self.assertNotEqual(dag_subclass, self.dag)\n\n # a dag should equal an unpickled version of itself\n d = pickle.dumps(self.dag)\n self.assertEqual(pickle.loads(d), self.dag)\n\n # dags are ordered based on dag_id no matter what the type is\n self.assertLess(self.dag, dag_diff_name)\n self.assertGreater(self.dag, dag_diff_load_time)\n self.assertLess(self.dag, dag_subclass_diff_name)\n\n # greater than should have been created automatically by functools\n self.assertGreater(dag_diff_name, self.dag)\n\n # hashes are non-random and match equality\n self.assertEqual(hash(self.dag), hash(self.dag))\n self.assertEqual(hash(dag_eq), hash(self.dag))\n self.assertNotEqual(hash(dag_diff_name), hash(self.dag))\n self.assertNotEqual(hash(dag_subclass), hash(self.dag))\n\n def test_check_operators(self):\n\n conn_id = \"sqlite_default\"\n\n captainHook = BaseHook.get_hook(conn_id=conn_id)\n captainHook.run(\"CREATE TABLE operator_test_table (a, b)\")\n captainHook.run(\"insert into operator_test_table values (1,2)\")\n\n t = CheckOperator(\n task_id='check',\n sql=\"select count(*) from operator_test_table\",\n conn_id=conn_id,\n dag=self.dag)\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n t = ValueCheckOperator(\n task_id='value_check',\n pass_value=95,\n tolerance=0.1,\n conn_id=conn_id,\n sql=\"SELECT 100\",\n dag=self.dag)\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n captainHook.run(\"drop table operator_test_table\")\n\n def test_clear_api(self):\n task = self.dag_bash.tasks[0]\n task.clear(\n start_date=DEFAULT_DATE, end_date=DEFAULT_DATE,\n upstream=True, downstream=True)\n ti = TaskInstance(task=task, execution_date=DEFAULT_DATE)\n ti.are_dependents_done()\n\n def test_illegal_args(self):\n \"\"\"\n Tests that Operators reject illegal arguments\n \"\"\"\n with warnings.catch_warnings(record=True) as w:\n BashOperator(\n task_id='test_illegal_args',\n bash_command='echo success',\n dag=self.dag,\n illegal_argument_1234='hello?')\n self.assertTrue(\n issubclass(w[0].category, PendingDeprecationWarning))\n self.assertIn(\n ('Invalid arguments were passed to BashOperator '\n '(task_id: test_illegal_args).'),\n w[0].message.args[0])\n\n def test_bash_operator(self):\n t = BashOperator(\n task_id='test_bash_operator',\n bash_command=\"echo success\",\n dag=self.dag)\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_bash_operator_multi_byte_output(self):\n t = BashOperator(\n task_id='test_multi_byte_bash_operator',\n bash_command=\"echo \\u2600\",\n dag=self.dag,\n output_encoding='utf-8')\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_bash_operator_kill(self):\n import psutil\n sleep_time = \"100%d\" % os.getpid()\n t = BashOperator(\n task_id='test_bash_operator_kill',\n execution_timeout=timedelta(seconds=1),\n bash_command=\"/bin/bash -c 'sleep %s'\" % sleep_time,\n dag=self.dag)\n self.assertRaises(\n exceptions.AirflowTaskTimeout,\n t.run,\n start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)\n sleep(2)\n pid = -1\n for proc in psutil.process_iter():\n if proc.cmdline() == ['sleep', sleep_time]:\n pid = proc.pid\n if pid != -1:\n os.kill(pid, signal.SIGTERM)\n self.fail(\"BashOperator's subprocess still running after stopping on timeout!\")\n\n def test_on_failure_callback(self):\n # Annoying workaround for nonlocal not existing in python 2\n data = {'called': False}\n\n def check_failure(context, test_case=self):\n data['called'] = True\n error = context.get('exception')\n test_case.assertIsInstance(error, AirflowException)\n\n t = BashOperator(\n task_id='check_on_failure_callback',\n bash_command=\"exit 1\",\n dag=self.dag,\n on_failure_callback=check_failure)\n self.assertRaises(\n exceptions.AirflowException,\n t.run,\n start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n self.assertTrue(data['called'])\n\n def test_trigger_dagrun(self):\n def trigga(_, obj):\n if True:\n return obj\n\n t = TriggerDagRunOperator(\n task_id='test_trigger_dagrun',\n trigger_dag_id='example_bash_operator',\n python_callable=trigga,\n dag=self.dag)\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_dryrun(self):\n t = BashOperator(\n task_id='test_dryrun',\n bash_command=\"echo success\",\n dag=self.dag)\n t.dry_run()\n\n def test_sqlite(self):\n import airflow.operators.sqlite_operator\n t = airflow.operators.sqlite_operator.SqliteOperator(\n task_id='time_sqlite',\n sql=\"CREATE TABLE IF NOT EXISTS unitest (dummy VARCHAR(20))\",\n dag=self.dag)\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_timeout(self):\n t = PythonOperator(\n task_id='test_timeout',\n execution_timeout=timedelta(seconds=1),\n python_callable=lambda: sleep(5),\n dag=self.dag)\n self.assertRaises(\n exceptions.AirflowTaskTimeout,\n t.run,\n start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_python_op(self):\n def test_py_op(templates_dict, ds, **kwargs):\n if not templates_dict['ds'] == ds:\n raise Exception(\"failure\")\n\n t = PythonOperator(\n task_id='test_py_op',\n python_callable=test_py_op,\n templates_dict={'ds': \"{{ ds }}\"},\n dag=self.dag)\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_complex_template(self):\n def verify_templated_field(context):\n self.assertEqual(context['ti'].task.some_templated_field['bar'][1],\n context['ds'])\n\n t = OperatorSubclass(\n task_id='test_complex_template',\n some_templated_field={\n 'foo': '123',\n 'bar': ['baz', '{{ ds }}']\n },\n dag=self.dag)\n t.execute = verify_templated_field\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_template_with_variable(self):\n \"\"\"\n Test the availability of variables in templates\n \"\"\"\n val = {\n 'test_value': 'a test value'\n }\n Variable.set(\"a_variable\", val['test_value'])\n\n def verify_templated_field(context):\n self.assertEqual(context['ti'].task.some_templated_field,\n val['test_value'])\n\n t = OperatorSubclass(\n task_id='test_complex_template',\n some_templated_field='{{ var.value.a_variable }}',\n dag=self.dag)\n t.execute = verify_templated_field\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_template_with_json_variable(self):\n \"\"\"\n Test the availability of variables (serialized as JSON) in templates\n \"\"\"\n val = {\n 'test_value': {'foo': 'bar', 'obj': {'v1': 'yes', 'v2': 'no'}}\n }\n Variable.set(\"a_variable\", val['test_value'], serialize_json=True)\n\n def verify_templated_field(context):\n self.assertEqual(context['ti'].task.some_templated_field,\n val['test_value']['obj']['v2'])\n\n t = OperatorSubclass(\n task_id='test_complex_template',\n some_templated_field='{{ var.json.a_variable.obj.v2 }}',\n dag=self.dag)\n t.execute = verify_templated_field\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_template_with_json_variable_as_value(self):\n \"\"\"\n Test the availability of variables (serialized as JSON) in templates, but\n accessed as a value\n \"\"\"\n val = {\n 'test_value': {'foo': 'bar'}\n }\n Variable.set(\"a_variable\", val['test_value'], serialize_json=True)\n\n def verify_templated_field(context):\n self.assertEqual(context['ti'].task.some_templated_field,\n '{\\n \"foo\": \"bar\"\\n}')\n\n t = OperatorSubclass(\n task_id='test_complex_template',\n some_templated_field='{{ var.value.a_variable }}',\n dag=self.dag)\n t.execute = verify_templated_field\n t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n\n def test_template_non_bool(self):\n \"\"\"\n Test templates can handle objects with no sense of truthiness\n \"\"\"\n\n class NonBoolObject:\n def __len__(self):\n return NotImplemented\n\n def __bool__(self):\n return NotImplemented\n\n t = OperatorSubclass(\n task_id='test_bad_template_obj',\n some_templated_field=NonBoolObject(),\n dag=self.dag)\n t.resolve_template_files()\n\n def test_task_get_template(self):\n TI = TaskInstance\n ti = TI(\n task=self.runme_0, execution_date=DEFAULT_DATE)\n ti.dag = self.dag_bash\n ti.run(ignore_ti_state=True)\n context = ti.get_template_context()\n\n # DEFAULT DATE is 2015-01-01\n self.assertEqual(context['ds'], '2015-01-01')\n self.assertEqual(context['ds_nodash'], '20150101')\n\n # next_ds is 2015-01-02 as the dag interval is daily\n self.assertEqual(context['next_ds'], '2015-01-02')\n self.assertEqual(context['next_ds_nodash'], '20150102')\n\n # prev_ds is 2014-12-31 as the dag interval is daily\n self.assertEqual(context['prev_ds'], '2014-12-31')\n self.assertEqual(context['prev_ds_nodash'], '20141231')\n\n self.assertEqual(context['ts'], '2015-01-01T00:00:00+00:00')\n self.assertEqual(context['ts_nodash'], '20150101T000000')\n self.assertEqual(context['ts_nodash_with_tz'], '20150101T000000+0000')\n\n self.assertEqual(context['yesterday_ds'], '2014-12-31')\n self.assertEqual(context['yesterday_ds_nodash'], '20141231')\n\n self.assertEqual(context['tomorrow_ds'], '2015-01-02')\n self.assertEqual(context['tomorrow_ds_nodash'], '20150102')\n\n def test_local_task_job(self):\n TI = TaskInstance\n ti = TI(\n task=self.runme_0, execution_date=DEFAULT_DATE)\n job = jobs.LocalTaskJob(task_instance=ti, ignore_ti_state=True)\n job.run()\n\n def test_raw_job(self):\n TI = TaskInstance\n ti = TI(\n task=self.runme_0, execution_date=DEFAULT_DATE)\n ti.dag = self.dag_bash\n ti.run(ignore_ti_state=True)\n\n def test_variable_set_get_round_trip(self):\n Variable.set(\"tested_var_set_id\", \"Monday morning breakfast\")\n self.assertEqual(\"Monday morning breakfast\", Variable.get(\"tested_var_set_id\"))\n\n def test_variable_set_get_round_trip_json(self):\n value = {\"a\": 17, \"b\": 47}\n Variable.set(\"tested_var_set_id\", value, serialize_json=True)\n self.assertEqual(value, Variable.get(\"tested_var_set_id\", deserialize_json=True))\n\n def test_get_non_existing_var_should_return_default(self):\n default_value = \"some default val\"\n self.assertEqual(default_value, Variable.get(\"thisIdDoesNotExist\",\n default_var=default_value))\n\n def test_get_non_existing_var_should_raise_key_error(self):\n with self.assertRaises(KeyError):\n Variable.get(\"thisIdDoesNotExist\")\n\n def test_get_non_existing_var_with_none_default_should_return_none(self):\n self.assertIsNone(Variable.get(\"thisIdDoesNotExist\", default_var=None))\n\n def test_get_non_existing_var_should_not_deserialize_json_default(self):\n default_value = \"}{ this is a non JSON default }{\"\n self.assertEqual(default_value, Variable.get(\"thisIdDoesNotExist\",\n default_var=default_value,\n deserialize_json=True))\n\n def test_variable_setdefault_round_trip(self):\n key = \"tested_var_setdefault_1_id\"\n value = \"Monday morning breakfast in Paris\"\n Variable.setdefault(key, value)\n self.assertEqual(value, Variable.get(key))\n\n def test_variable_setdefault_round_trip_json(self):\n key = \"tested_var_setdefault_2_id\"\n value = {\"city\": 'Paris', \"Happiness\": True}\n Variable.setdefault(key, value, deserialize_json=True)\n self.assertEqual(value, Variable.get(key, deserialize_json=True))\n\n def test_variable_setdefault_existing_json(self):\n key = \"tested_var_setdefault_2_id\"\n value = {\"city\": 'Paris', \"Happiness\": True}\n Variable.set(key, value, serialize_json=True)\n val = Variable.setdefault(key, value, deserialize_json=True)\n # Check the returned value, and the stored value are handled correctly.\n self.assertEqual(value, val)\n self.assertEqual(value, Variable.get(key, deserialize_json=True))\n\n def test_variable_delete(self):\n key = \"tested_var_delete\"\n value = \"to be deleted\"\n\n # No-op if the variable doesn't exist\n Variable.delete(key)\n with self.assertRaises(KeyError):\n Variable.get(key)\n\n # Set the variable\n Variable.set(key, value)\n self.assertEqual(value, Variable.get(key))\n\n # Delete the variable\n Variable.delete(key)\n with self.assertRaises(KeyError):\n Variable.get(key)\n\n def test_parameterized_config_gen(self):\n\n cfg = configuration.parameterized_config(configuration.DEFAULT_CONFIG)\n\n # making sure some basic building blocks are present:\n self.assertIn(\"[core]\", cfg)\n self.assertIn(\"dags_folder\", cfg)\n self.assertIn(\"sql_alchemy_conn\", cfg)\n self.assertIn(\"fernet_key\", cfg)\n\n # making sure replacement actually happened\n self.assertNotIn(\"{AIRFLOW_HOME}\", cfg)\n self.assertNotIn(\"{FERNET_KEY}\", cfg)\n\n def test_config_use_original_when_original_and_fallback_are_present(self):\n self.assertTrue(conf.has_option(\"core\", \"FERNET_KEY\"))\n self.assertFalse(conf.has_option(\"core\", \"FERNET_KEY_CMD\"))\n\n FERNET_KEY = conf.get('core', 'FERNET_KEY')\n\n with conf_vars({('core', 'FERNET_KEY_CMD'): 'printf HELLO'}):\n FALLBACK_FERNET_KEY = conf.get(\n \"core\",\n \"FERNET_KEY\"\n )\n\n self.assertEqual(FERNET_KEY, FALLBACK_FERNET_KEY)\n\n def test_config_throw_error_when_original_and_fallback_is_absent(self):\n self.assertTrue(conf.has_option(\"core\", \"FERNET_KEY\"))\n self.assertFalse(conf.has_option(\"core\", \"FERNET_KEY_CMD\"))\n\n with conf_vars({('core', 'fernet_key'): None}):\n with self.assertRaises(AirflowConfigException) as cm:\n conf.get(\"core\", \"FERNET_KEY\")\n\n exception = str(cm.exception)\n message = \"section/key [core/fernet_key] not found in config\"\n self.assertEqual(message, exception)\n\n def test_config_override_original_when_non_empty_envvar_is_provided(self):\n key = \"AIRFLOW__CORE__FERNET_KEY\"\n value = \"some value\"\n self.assertNotIn(key, os.environ)\n\n os.environ[key] = value\n FERNET_KEY = conf.get('core', 'FERNET_KEY')\n self.assertEqual(value, FERNET_KEY)\n\n # restore the envvar back to the original state\n del os.environ[key]\n\n def test_config_override_original_when_empty_envvar_is_provided(self):\n key = \"AIRFLOW__CORE__FERNET_KEY\"\n value = \"\"\n self.assertNotIn(key, os.environ)\n\n os.environ[key] = value\n FERNET_KEY = conf.get('core', 'FERNET_KEY')\n self.assertEqual(value, FERNET_KEY)\n\n # restore the envvar back to the original state\n del os.environ[key]\n\n def test_round_time(self):\n\n rt1 = round_time(datetime(2015, 1, 1, 6), timedelta(days=1))\n self.assertEqual(datetime(2015, 1, 1, 0, 0), rt1)\n\n rt2 = round_time(datetime(2015, 1, 2), relativedelta(months=1))\n self.assertEqual(datetime(2015, 1, 1, 0, 0), rt2)\n\n rt3 = round_time(datetime(2015, 9, 16, 0, 0), timedelta(1), datetime(\n 2015, 9, 14, 0, 0))\n self.assertEqual(datetime(2015, 9, 16, 0, 0), rt3)\n\n rt4 = round_time(datetime(2015, 9, 15, 0, 0), timedelta(1), datetime(\n 2015, 9, 14, 0, 0))\n self.assertEqual(datetime(2015, 9, 15, 0, 0), rt4)\n\n rt5 = round_time(datetime(2015, 9, 14, 0, 0), timedelta(1), datetime(\n 2015, 9, 14, 0, 0))\n self.assertEqual(datetime(2015, 9, 14, 0, 0), rt5)\n\n rt6 = round_time(datetime(2015, 9, 13, 0, 0), timedelta(1), datetime(\n 2015, 9, 14, 0, 0))\n self.assertEqual(datetime(2015, 9, 14, 0, 0), rt6)\n\n def test_infer_time_unit(self):\n\n self.assertEqual('minutes', infer_time_unit([130, 5400, 10]))\n\n self.assertEqual('seconds', infer_time_unit([110, 50, 10, 100]))\n\n self.assertEqual('hours', infer_time_unit([100000, 50000, 10000, 20000]))\n\n self.assertEqual('days', infer_time_unit([200000, 100000]))\n\n def test_scale_time_units(self):\n\n # use assert_almost_equal from numpy.testing since we are comparing\n # floating point arrays\n arr1 = scale_time_units([130, 5400, 10], 'minutes')\n assert_array_almost_equal(arr1, [2.167, 90.0, 0.167], decimal=3)\n\n arr2 = scale_time_units([110, 50, 10, 100], 'seconds')\n assert_array_almost_equal(arr2, [110.0, 50.0, 10.0, 100.0], decimal=3)\n\n arr3 = scale_time_units([100000, 50000, 10000, 20000], 'hours')\n assert_array_almost_equal(arr3, [27.778, 13.889, 2.778, 5.556],\n decimal=3)\n\n arr4 = scale_time_units([200000, 100000], 'days')\n assert_array_almost_equal(arr4, [2.315, 1.157], decimal=3)\n\n def test_bad_trigger_rule(self):\n with self.assertRaises(AirflowException):\n DummyOperator(\n task_id='test_bad_trigger',\n trigger_rule=\"non_existent\",\n dag=self.dag)\n\n def test_terminate_task(self):\n \"\"\"If a task instance's db state get deleted, it should fail\"\"\"\n TI = TaskInstance\n dag = self.dagbag.dags.get('test_utils')\n task = dag.task_dict.get('sleeps_forever')\n\n ti = TI(task=task, execution_date=DEFAULT_DATE)\n job = jobs.LocalTaskJob(\n task_instance=ti, ignore_ti_state=True, executor=SequentialExecutor())\n\n # Running task instance asynchronously\n p = multiprocessing.Process(target=job.run)\n p.start()\n sleep(5)\n settings.engine.dispose()\n session = settings.Session()\n ti.refresh_from_db(session=session)\n # making sure it's actually running\n self.assertEqual(State.RUNNING, ti.state)\n ti = session.query(TI).filter_by(\n dag_id=task.dag_id,\n task_id=task.task_id,\n execution_date=DEFAULT_DATE\n ).one()\n\n # deleting the instance should result in a failure\n session.delete(ti)\n session.commit()\n # waiting for the async task to finish\n p.join()\n\n # making sure that the task ended up as failed\n ti.refresh_from_db(session=session)\n self.assertEqual(State.FAILED, ti.state)\n session.close()\n\n def test_task_fail_duration(self):\n \"\"\"If a task fails, the duration should be recorded in TaskFail\"\"\"\n\n p = BashOperator(\n task_id='pass_sleepy',\n bash_command='sleep 3',\n dag=self.dag)\n f = BashOperator(\n task_id='fail_sleepy',\n bash_command='sleep 5',\n execution_timeout=timedelta(seconds=3),\n retry_delay=timedelta(seconds=0),\n dag=self.dag)\n session = settings.Session()\n try:\n p.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n except Exception:\n pass\n try:\n f.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n except Exception:\n pass\n p_fails = session.query(TaskFail).filter_by(\n task_id='pass_sleepy',\n dag_id=self.dag.dag_id,\n execution_date=DEFAULT_DATE).all()\n f_fails = session.query(TaskFail).filter_by(\n task_id='fail_sleepy',\n dag_id=self.dag.dag_id,\n execution_date=DEFAULT_DATE).all()\n\n self.assertEqual(0, len(p_fails))\n self.assertEqual(1, len(f_fails))\n self.assertGreaterEqual(sum([f.duration for f in f_fails]), 3)\n\n def test_run_command(self):\n write = r'sys.stdout.buffer.write(\"\\u1000foo\".encode(\"utf8\"))'\n\n cmd = 'import sys; {0}; sys.stdout.flush()'.format(write)\n\n self.assertEqual(run_command(\"python -c '{0}'\".format(cmd)), '\\u1000foo')\n\n self.assertEqual(run_command('echo \"foo bar\"'), 'foo bar\\n')\n self.assertRaises(AirflowConfigException, run_command, 'bash -c \"exit 1\"')\n\n def test_trigger_dagrun_with_execution_date(self):\n utc_now = timezone.utcnow()\n run_id = 'trig__' + utc_now.isoformat()\n\n def payload_generator(context, object): # pylint: disable=unused-argument\n object.run_id = run_id\n return object\n\n task = TriggerDagRunOperator(task_id='test_trigger_dagrun_with_execution_date',\n trigger_dag_id='example_bash_operator',\n python_callable=payload_generator,\n execution_date=utc_now,\n dag=self.dag)\n task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n dag_runs = DagRun.find(dag_id='example_bash_operator', run_id=run_id)\n self.assertEqual(len(dag_runs), 1)\n dag_run = dag_runs[0]\n self.assertEqual(dag_run.execution_date, utc_now)\n\n def test_trigger_dagrun_with_str_execution_date(self):\n utc_now_str = timezone.utcnow().isoformat()\n self.assertIsInstance(utc_now_str, (str,))\n run_id = 'trig__' + utc_now_str\n\n def payload_generator(context, object): # pylint: disable=unused-argument\n object.run_id = run_id\n return object\n\n task = TriggerDagRunOperator(\n task_id='test_trigger_dagrun_with_str_execution_date',\n trigger_dag_id='example_bash_operator',\n python_callable=payload_generator,\n execution_date=utc_now_str,\n dag=self.dag)\n task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)\n dag_runs = DagRun.find(dag_id='example_bash_operator', run_id=run_id)\n self.assertEqual(len(dag_runs), 1)\n dag_run = dag_runs[0]\n self.assertEqual(dag_run.execution_date.isoformat(), utc_now_str)\n\n def test_trigger_dagrun_with_templated_execution_date(self):\n task = TriggerDagRunOperator(\n task_id='test_trigger_dagrun_with_str_execution_date',\n trigger_dag_id='example_bash_operator',\n execution_date='{{ execution_date }}',\n dag=self.dag)\n\n self.assertTrue(isinstance(task.execution_date, str))\n self.assertEqual(task.execution_date, '{{ execution_date }}')\n\n ti = TaskInstance(task=task, execution_date=DEFAULT_DATE)\n ti.render_templates()\n self.assertEqual(timezone.parse(task.execution_date), DEFAULT_DATE)\n\n def test_externally_triggered_dagrun(self):\n TI = TaskInstance\n\n # Create the dagrun between two \"scheduled\" execution dates of the DAG\n EXECUTION_DATE = DEFAULT_DATE + timedelta(days=2)\n EXECUTION_DS = EXECUTION_DATE.strftime('%Y-%m-%d')\n EXECUTION_DS_NODASH = EXECUTION_DS.replace('-', '')\n\n dag = DAG(\n TEST_DAG_ID,\n default_args=self.args,\n schedule_interval=timedelta(weeks=1),\n start_date=DEFAULT_DATE)\n task = DummyOperator(task_id='test_externally_triggered_dag_context',\n dag=dag)\n dag.create_dagrun(run_id=DagRun.id_for_date(EXECUTION_DATE),\n execution_date=EXECUTION_DATE,\n state=State.RUNNING,\n external_trigger=True)\n task.run(\n start_date=EXECUTION_DATE, end_date=EXECUTION_DATE)\n\n ti = TI(task=task, execution_date=EXECUTION_DATE)\n context = ti.get_template_context()\n\n # next_ds/prev_ds should be the execution date for manually triggered runs\n self.assertEqual(context['next_ds'], EXECUTION_DS)\n self.assertEqual(context['next_ds_nodash'], EXECUTION_DS_NODASH)\n\n self.assertEqual(context['prev_ds'], EXECUTION_DS)\n self.assertEqual(context['prev_ds_nodash'], EXECUTION_DS_NODASH)\n\n\nclass TestCli(unittest.TestCase):\n\n TEST_USER1_EMAIL = 'test-user1@example.com'\n TEST_USER2_EMAIL = 'test-user2@example.com'\n\n @classmethod\n def setUpClass(cls):\n super().setUpClass()\n cls._cleanup()\n\n def setUp(self):\n super().setUp()\n from airflow.www import app as application\n self.app, self.appbuilder = application.create_app(session=Session, testing=True)\n self.app.config['TESTING'] = True\n\n self.parser = cli.CLIFactory.get_parser()\n self.dagbag = DagBag(dag_folder=DEV_NULL, include_examples=True)\n settings.configure_orm()\n self.session = Session\n\n def tearDown(self):\n self._cleanup(session=self.session)\n for email in [self.TEST_USER1_EMAIL, self.TEST_USER2_EMAIL]:\n test_user = self.appbuilder.sm.find_user(email=email)\n if test_user:\n self.appbuilder.sm.del_register_user(test_user)\n for role_name in ['FakeTeamA', 'FakeTeamB']:\n if self.appbuilder.sm.find_role(role_name):\n self.appbuilder.sm.delete_role(role_name)\n\n super().tearDown()\n\n @staticmethod\n def _cleanup(session=None):\n if session is None:\n session = Session()\n\n session.query(Pool).delete()\n session.query(Variable).delete()\n session.commit()\n session.close()\n\n def test_cli_list_dags(self):\n args = self.parser.parse_args(['dags', 'list', '--report'])\n cli.list_dags(args)\n\n def test_cli_list_dag_runs(self):\n cli.trigger_dag(self.parser.parse_args([\n 'dags', 'trigger', 'example_bash_operator', ]))\n args = self.parser.parse_args(['dags', 'list_runs',\n 'example_bash_operator',\n '--no_backfill'])\n cli.list_dag_runs(args)\n\n def test_cli_create_user_random_password(self):\n args = self.parser.parse_args([\n 'users', 'create', '--username', 'test1', '--lastname', 'doe',\n '--firstname', 'jon',\n '--email', 'jdoe@foo.com', '--role', 'Viewer', '--use_random_password'\n ])\n cli.users_create(args)\n\n def test_cli_create_user_supplied_password(self):\n args = self.parser.parse_args([\n 'users', 'create', '--username', 'test2', '--lastname', 'doe',\n '--firstname', 'jon',\n '--email', 'jdoe@apache.org', '--role', 'Viewer', '--password', 'test'\n ])\n cli.users_create(args)\n\n def test_cli_delete_user(self):\n args = self.parser.parse_args([\n 'users', 'create', '--username', 'test3', '--lastname', 'doe',\n '--firstname', 'jon',\n '--email', 'jdoe@example.com', '--role', 'Viewer', '--use_random_password'\n ])\n cli.users_create(args)\n args = self.parser.parse_args([\n 'users', 'delete', '--username', 'test3',\n ])\n cli.users_delete(args)\n\n def test_cli_list_users(self):\n for i in range(0, 3):\n args = self.parser.parse_args([\n 'users', 'create', '--username', 'user{}'.format(i), '--lastname',\n 'doe', '--firstname', 'jon',\n '--email', 'jdoe+{}@gmail.com'.format(i), '--role', 'Viewer',\n '--use_random_password'\n ])\n cli.users_create(args)\n with mock.patch('sys.stdout', new_callable=io.StringIO) as mock_stdout:\n cli.users_list(self.parser.parse_args(['users', 'list']))\n stdout = mock_stdout.getvalue()\n for i in range(0, 3):\n self.assertIn('user{}'.format(i), stdout)\n\n def test_cli_import_users(self):\n def assertUserInRoles(email, roles):\n for role in roles:\n self.assertTrue(self._does_user_belong_to_role(email, role))\n\n def assertUserNotInRoles(email, roles):\n for role in roles:\n self.assertFalse(self._does_user_belong_to_role(email, role))\n\n assertUserNotInRoles(self.TEST_USER1_EMAIL, ['Admin', 'Op'])\n assertUserNotInRoles(self.TEST_USER2_EMAIL, ['Public'])\n users = [\n {\n \"username\": \"imported_user1\", \"lastname\": \"doe1\",\n \"firstname\": \"jon\", \"email\": self.TEST_USER1_EMAIL,\n \"roles\": [\"Admin\", \"Op\"]\n },\n {\n \"username\": \"imported_user2\", \"lastname\": \"doe2\",\n \"firstname\": \"jon\", \"email\": self.TEST_USER2_EMAIL,\n \"roles\": [\"Public\"]\n }\n ]\n self._import_users_from_file(users)\n\n assertUserInRoles(self.TEST_USER1_EMAIL, ['Admin', 'Op'])\n assertUserInRoles(self.TEST_USER2_EMAIL, ['Public'])\n\n users = [\n {\n \"username\": \"imported_user1\", \"lastname\": \"doe1\",\n \"firstname\": \"jon\", \"email\": self.TEST_USER1_EMAIL,\n \"roles\": [\"Public\"]\n },\n {\n \"username\": \"imported_user2\", \"lastname\": \"doe2\",\n \"firstname\": \"jon\", \"email\": self.TEST_USER2_EMAIL,\n \"roles\": [\"Admin\"]\n }\n ]\n self._import_users_from_file(users)\n\n assertUserNotInRoles(self.TEST_USER1_EMAIL, ['Admin', 'Op'])\n assertUserInRoles(self.TEST_USER1_EMAIL, ['Public'])\n assertUserNotInRoles(self.TEST_USER2_EMAIL, ['Public'])\n assertUserInRoles(self.TEST_USER2_EMAIL, ['Admin'])\n\n def test_cli_export_users(self):\n user1 = {\"username\": \"imported_user1\", \"lastname\": \"doe1\",\n \"firstname\": \"jon\", \"email\": self.TEST_USER1_EMAIL,\n \"roles\": [\"Public\"]}\n user2 = {\"username\": \"imported_user2\", \"lastname\": \"doe2\",\n \"firstname\": \"jon\", \"email\": self.TEST_USER2_EMAIL,\n \"roles\": [\"Admin\"]}\n self._import_users_from_file([user1, user2])\n\n users_filename = self._export_users_to_file()\n with open(users_filename, mode='r') as file:\n retrieved_users = json.loads(file.read())\n os.remove(users_filename)\n\n # ensure that an export can be imported\n self._import_users_from_file(retrieved_users)\n\n def find_by_username(username):\n matches = [u for u in retrieved_users\n if u['username'] == username]\n if not matches:\n self.fail(\"Couldn't find user with username {}\".format(username))\n else:\n matches[0].pop('id') # this key not required for import\n return matches[0]\n\n self.assertEqual(find_by_username('imported_user1'), user1)\n self.assertEqual(find_by_username('imported_user2'), user2)\n\n def _import_users_from_file(self, user_list):\n json_file_content = json.dumps(user_list)\n f = NamedTemporaryFile(delete=False)\n try:\n f.write(json_file_content.encode())\n f.flush()\n\n args = self.parser.parse_args([\n 'users', 'import', f.name\n ])\n cli.users_import(args)\n finally:\n os.remove(f.name)\n\n def _export_users_to_file(self):\n f = NamedTemporaryFile(delete=False)\n args = self.parser.parse_args([\n 'users', 'export', f.name\n ])\n cli.users_export(args)\n return f.name\n\n def _does_user_belong_to_role(self, email, rolename):\n user = self.appbuilder.sm.find_user(email=email)\n role = self.appbuilder.sm.find_role(rolename)\n if user and role:\n return role in user.roles\n\n return False\n\n def test_cli_add_user_role(self):\n args = self.parser.parse_args([\n 'users', 'create', '--username', 'test4', '--lastname', 'doe',\n '--firstname', 'jon',\n '--email', self.TEST_USER1_EMAIL, '--role', 'Viewer', '--use_random_password'\n ])\n cli.users_create(args)\n\n self.assertFalse(\n self._does_user_belong_to_role(email=self.TEST_USER1_EMAIL,\n rolename='Op'),\n \"User should not yet be a member of role 'Op'\"\n )\n\n args = self.parser.parse_args([\n 'users', 'add_role', '--username', 'test4', '--role', 'Op'\n ])\n cli.users_manage_role(args, remove=False)\n\n self.assertTrue(\n self._does_user_belong_to_role(email=self.TEST_USER1_EMAIL,\n rolename='Op'),\n \"User should have been added to role 'Op'\"\n )\n\n def test_cli_remove_user_role(self):\n args = self.parser.parse_args([\n 'users', 'create', '--username', 'test4', '--lastname', 'doe',\n '--firstname', 'jon',\n '--email', self.TEST_USER1_EMAIL, '--role', 'Viewer', '--use_random_password'\n ])\n cli.users_create(args)\n\n self.assertTrue(\n self._does_user_belong_to_role(email=self.TEST_USER1_EMAIL,\n rolename='Viewer'),\n \"User should have been created with role 'Viewer'\"\n )\n\n args = self.parser.parse_args([\n 'users', 'remove_role', '--username', 'test4', '--role', 'Viewer'\n ])\n cli.users_manage_role(args, remove=True)\n\n self.assertFalse(\n self._does_user_belong_to_role(email=self.TEST_USER1_EMAIL,\n rolename='Viewer'),\n \"User should have been removed from role 'Viewer'\"\n )\n\n @mock.patch(\"airflow.bin.cli.DagBag\")\n def test_cli_sync_perm(self, dagbag_mock):\n self.expect_dagbag_contains([\n DAG('has_access_control',\n access_control={\n 'Public': {'can_dag_read'}\n }),\n DAG('no_access_control')\n ], dagbag_mock)\n self.appbuilder.sm = mock.Mock()\n\n args = self.parser.parse_args([\n 'sync_perm'\n ])\n cli.sync_perm(args)\n\n assert self.appbuilder.sm.sync_roles.call_count == 1\n\n self.assertEqual(2,\n len(self.appbuilder.sm.sync_perm_for_dag.mock_calls))\n self.appbuilder.sm.sync_perm_for_dag.assert_any_call(\n 'has_access_control',\n {'Public': {'can_dag_read'}}\n )\n self.appbuilder.sm.sync_perm_for_dag.assert_any_call(\n 'no_access_control',\n None,\n )\n\n def expect_dagbag_contains(self, dags, dagbag_mock):\n dagbag = mock.Mock()\n dagbag.dags = {dag.dag_id: dag for dag in dags}\n dagbag_mock.return_value = dagbag\n\n def test_cli_create_roles(self):\n self.assertIsNone(self.appbuilder.sm.find_role('FakeTeamA'))\n self.assertIsNone(self.appbuilder.sm.find_role('FakeTeamB'))\n\n args = self.parser.parse_args([\n 'roles', 'create', 'FakeTeamA', 'FakeTeamB'\n ])\n cli.roles_create(args)\n\n self.assertIsNotNone(self.appbuilder.sm.find_role('FakeTeamA'))\n self.assertIsNotNone(self.appbuilder.sm.find_role('FakeTeamB'))\n\n def test_cli_create_roles_is_reentrant(self):\n self.assertIsNone(self.appbuilder.sm.find_role('FakeTeamA'))\n self.assertIsNone(self.appbuilder.sm.find_role('FakeTeamB'))\n\n args = self.parser.parse_args([\n 'roles', 'create', 'FakeTeamA', 'FakeTeamB'\n ])\n\n cli.roles_create(args)\n\n self.assertIsNotNone(self.appbuilder.sm.find_role('FakeTeamA'))\n self.assertIsNotNone(self.appbuilder.sm.find_role('FakeTeamB'))\n\n def test_cli_list_roles(self):\n self.appbuilder.sm.add_role('FakeTeamA')\n self.appbuilder.sm.add_role('FakeTeamB')\n\n with mock.patch('sys.stdout', new_callable=io.StringIO) as mock_stdout:\n cli.roles_list(self.parser.parse_args(['roles', 'list']))\n stdout = mock_stdout.getvalue()\n\n self.assertIn('FakeTeamA', stdout)\n self.assertIn('FakeTeamB', stdout)\n\n def test_cli_list_tasks(self):\n for dag_id in self.dagbag.dags.keys():\n args = self.parser.parse_args(['tasks', 'list', dag_id])\n cli.list_tasks(args)\n\n args = self.parser.parse_args([\n 'tasks', 'list', 'example_bash_operator', '--tree'])\n cli.list_tasks(args)\n\n def test_cli_list_jobs(self):\n args = self.parser.parse_args(['dags', 'list_jobs'])\n cli.list_jobs(args)\n\n def test_cli_list_jobs_with_args(self):\n args = self.parser.parse_args(['dags', 'list_jobs', '--dag_id',\n 'example_bash_operator',\n '--state', 'success',\n '--limit', '100'])\n cli.list_jobs(args)\n\n @mock.patch(\"airflow.bin.cli.db.initdb\")\n def test_cli_initdb(self, initdb_mock):\n cli.initdb(self.parser.parse_args(['db', 'init']))\n\n initdb_mock.assert_called_once_with()\n\n @mock.patch(\"airflow.bin.cli.db.resetdb\")\n def test_cli_resetdb(self, resetdb_mock):\n cli.resetdb(self.parser.parse_args(['db', 'reset', '--yes']))\n\n resetdb_mock.assert_called_once_with()\n\n def test_cli_connections_list(self):\n with mock.patch('sys.stdout', new_callable=io.StringIO) as mock_stdout:\n cli.connections_list(self.parser.parse_args(['connections', 'list']))\n stdout = mock_stdout.getvalue()\n conns = [[x.strip(\"'\") for x in re.findall(r\"'\\w+'\", line)[:2]]\n for ii, line in enumerate(stdout.split('\\n'))\n if ii % 2 == 1]\n conns = [conn for conn in conns if len(conn) > 0]\n\n # Assert that some of the connections are present in the output as\n # expected:\n self.assertIn(['aws_default', 'aws'], conns)\n self.assertIn(['hive_cli_default', 'hive_cli'], conns)\n self.assertIn(['emr_default', 'emr'], conns)\n self.assertIn(['mssql_default', 'mssql'], conns)\n self.assertIn(['mysql_default', 'mysql'], conns)\n self.assertIn(['postgres_default', 'postgres'], conns)\n self.assertIn(['wasb_default', 'wasb'], conns)\n self.assertIn(['segment_default', 'segment'], conns)\n\n def test_cli_connections_list_redirect(self):\n cmd = ['airflow', 'connections', 'list']\n with tempfile.TemporaryFile() as fp:\n p = subprocess.Popen(cmd, stdout=fp)\n p.wait()\n self.assertEqual(0, p.returncode)\n\n def test_cli_connections_add_delete(self):\n # Add connections:\n uri = 'postgresql://airflow:airflow@host:5432/airflow'\n with mock.patch('sys.stdout', new_callable=io.StringIO) as mock_stdout:\n cli.connections_add(self.parser.parse_args(\n ['connections', 'add', 'new1',\n '--conn_uri=%s' % uri]))\n cli.connections_add(self.parser.parse_args(\n ['connections', 'add', 'new2',\n '--conn_uri=%s' % uri]))\n cli.connections_add(self.parser.parse_args(\n ['connections', 'add', 'new3',\n '--conn_uri=%s' % uri, '--conn_extra', \"{'extra': 'yes'}\"]))\n cli.connections_add(self.parser.parse_args(\n ['connections', 'add', 'new4',\n '--conn_uri=%s' % uri, '--conn_extra', \"{'extra': 'yes'}\"]))\n cli.connections_add(self.parser.parse_args(\n ['connections', 'add', 'new5',\n '--conn_type=hive_metastore', '--conn_login=airflow',\n '--conn_password=airflow', '--conn_host=host',\n '--conn_port=9083', '--conn_schema=airflow']))\n cli.connections_add(self.parser.parse_args(\n ['connections', 'add', 'new6',\n '--conn_uri', \"\", '--conn_type=google_cloud_platform', '--conn_extra', \"{'extra': 'yes'}\"]))\n stdout = mock_stdout.getvalue()\n\n # Check addition stdout\n lines = [l for l in stdout.split('\\n') if len(l) > 0]\n self.assertListEqual(lines, [\n (\"\\tSuccessfully added `conn_id`=new1 : \" +\n \"postgresql://airflow:airflow@host:5432/airflow\"),\n (\"\\tSuccessfully added `conn_id`=new2 : \" +\n \"postgresql://airflow:airflow@host:5432/airflow\"),\n (\"\\tSuccessfully added `conn_id`=new3 : \" +\n \"postgresql://airflow:airflow@host:5432/airflow\"),\n (\"\\tSuccessfully added `conn_id`=new4 : \" +\n \"postgresql://airflow:airflow@host:5432/airflow\"),\n (\"\\tSuccessfully added `conn_id`=new5 : \" +\n \"hive_metastore://airflow:airflow@host:9083/airflow\"),\n (\"\\tSuccessfully added `conn_id`=new6 : \" +\n \"google_cloud_platform://:@:\")\n ])\n\n # Attempt to add duplicate\n with mock.patch('sys.stdout', new_callable=io.StringIO) as mock_stdout:\n cli.connections_add(self.parser.parse_args(\n ['connections', 'add', 'new1',\n '--conn_uri=%s' % uri]))\n stdout = mock_stdout.getvalue()\n\n # Check stdout for addition attempt\n lines = [l for l in stdout.split('\\n') if len(l) > 0]\n self.assertListEqual(lines, [\n \"\\tA connection with `conn_id`=new1 already exists\",\n ])\n\n # Attempt to add without providing conn_uri\n with self.assertRaises(SystemExit) as exc:\n cli.connections_add(self.parser.parse_args(\n ['connections', 'add', 'new']))\n\n self.assertEqual(\n exc.exception.code,\n \"The following args are required to add a connection: ['conn_uri or conn_type']\"\n )\n\n # Prepare to add connections\n session = settings.Session()\n extra = {'new1': None,\n 'new2': None,\n 'new3': \"{'extra': 'yes'}\",\n 'new4': \"{'extra': 'yes'}\"}\n\n # Add connections\n for index in range(1, 6):\n conn_id = 'new%s' % index\n result = (session\n .query(Connection)\n .filter(Connection.conn_id == conn_id)\n .first())\n result = (result.conn_id, result.conn_type, result.host,\n result.port, result.get_extra())\n if conn_id in ['new1', 'new2', 'new3', 'new4']:\n self.assertEqual(result, (conn_id, 'postgres', 'host', 5432,\n extra[conn_id]))\n elif conn_id == 'new5':\n self.assertEqual(result, (conn_id, 'hive_metastore', 'host',\n 9083, None))\n elif conn_id == 'new6':\n self.assertEqual(result, (conn_id, 'google_cloud_platform',\n None, None, \"{'extra': 'yes'}\"))\n\n # Delete connections\n with mock.patch('sys.stdout', new_callable=io.StringIO) as mock_stdout:\n cli.connections_delete(self.parser.parse_args(\n ['connections', 'delete', 'new1']))\n cli.connections_delete(self.parser.parse_args(\n ['connections', 'delete', 'new2']))\n cli.connections_delete(self.parser.parse_args(\n ['connections', 'delete', 'new3']))\n cli.connections_delete(self.parser.parse_args(\n ['connections', 'delete', 'new4']))\n cli.connections_delete(self.parser.parse_args(\n ['connections', 'delete', 'new5']))\n cli.connections_delete(self.parser.parse_args(\n ['connections', 'delete', 'new6']))\n stdout = mock_stdout.getvalue()\n\n # Check deletion stdout\n lines = [l for l in stdout.split('\\n') if len(l) > 0]\n self.assertListEqual(lines, [\n \"\\tSuccessfully deleted `conn_id`=new1\",\n \"\\tSuccessfully deleted `conn_id`=new2\",\n \"\\tSuccessfully deleted `conn_id`=new3\",\n \"\\tSuccessfully deleted `conn_id`=new4\",\n \"\\tSuccessfully deleted `conn_id`=new5\",\n \"\\tSuccessfully deleted `conn_id`=new6\"\n ])\n\n # Check deletions\n for index in range(1, 7):\n conn_id = 'new%s' % index\n result = (session.query(Connection)\n .filter(Connection.conn_id == conn_id)\n .first())\n\n self.assertTrue(result is None)\n\n # Attempt to delete a non-existing connection\n with mock.patch('sys.stdout', new_callable=io.StringIO) as mock_stdout:\n cli.connections_delete(self.parser.parse_args(\n ['connections', 'delete', 'fake']))\n stdout = mock_stdout.getvalue()\n\n # Check deletion attempt stdout\n lines = [l for l in stdout.split('\\n') if len(l) > 0]\n self.assertListEqual(lines, [\n \"\\tDid not find a connection with `conn_id`=fake\",\n ])\n\n session.close()\n\n def test_cli_test(self):\n cli.test(self.parser.parse_args([\n 'tasks', 'test', 'example_bash_operator', 'runme_0',\n DEFAULT_DATE.isoformat()]))\n cli.test(self.parser.parse_args([\n 'tasks', 'test', 'example_bash_operator', 'runme_0', '--dry_run',\n DEFAULT_DATE.isoformat()]))\n\n def test_cli_test_with_params(self):\n cli.test(self.parser.parse_args([\n 'tasks', 'test', 'example_passing_params_via_test_command', 'run_this',\n '-tp', '{\"foo\":\"bar\"}', DEFAULT_DATE.isoformat()]))\n cli.test(self.parser.parse_args([\n 'tasks', 'test', 'example_passing_params_via_test_command', 'also_run_this',\n '-tp', '{\"foo\":\"bar\"}', DEFAULT_DATE.isoformat()]))\n\n def test_cli_run(self):\n cli.run(self.parser.parse_args([\n 'tasks', 'run', 'example_bash_operator', 'runme_0', '-l',\n DEFAULT_DATE.isoformat()]))\n\n def test_task_state(self):\n cli.task_state(self.parser.parse_args([\n 'tasks', 'state', 'example_bash_operator', 'runme_0',\n DEFAULT_DATE.isoformat()]))\n\n def test_dag_state(self):\n self.assertEqual(None, cli.dag_state(self.parser.parse_args([\n 'dags', 'state', 'example_bash_operator', DEFAULT_DATE.isoformat()])))\n\n def test_pause(self):\n args = self.parser.parse_args([\n 'dags', 'pause', 'example_bash_operator'])\n cli.pause(args)\n self.assertIn(self.dagbag.dags['example_bash_operator'].is_paused, [True, 1])\n\n args = self.parser.parse_args([\n 'dags', 'unpause', 'example_bash_operator'])\n cli.unpause(args)\n self.assertIn(self.dagbag.dags['example_bash_operator'].is_paused, [False, 0])\n\n def test_subdag_clear(self):\n args = self.parser.parse_args([\n 'tasks', 'clear', 'example_subdag_operator', '--no_confirm'])\n cli.clear(args)\n args = self.parser.parse_args([\n 'tasks', 'clear', 'example_subdag_operator', '--no_confirm', '--exclude_subdags'])\n cli.clear(args)\n\n def test_parentdag_downstream_clear(self):\n args = self.parser.parse_args([\n 'tasks', 'clear', 'example_subdag_operator.section-1', '--no_confirm'])\n cli.clear(args)\n args = self.parser.parse_args([\n 'tasks', 'clear', 'example_subdag_operator.section-1', '--no_confirm',\n '--exclude_parentdag'])\n cli.clear(args)\n\n def test_get_dags(self):\n dags = cli.get_dags(self.parser.parse_args(['tasks', 'clear', 'example_subdag_operator',\n '-c']))\n self.assertEqual(len(dags), 1)\n\n dags = cli.get_dags(self.parser.parse_args(['tasks', 'clear', 'subdag', '-dx', '-c']))\n self.assertGreater(len(dags), 1)\n\n with self.assertRaises(AirflowException):\n cli.get_dags(self.parser.parse_args(['tasks', 'clear', 'foobar', '-dx', '-c']))\n\n def test_process_subdir_path_with_placeholder(self):\n self.assertEqual(os.path.join(settings.DAGS_FOLDER, 'abc'), cli.process_subdir('DAGS_FOLDER/abc'))\n\n def test_trigger_dag(self):\n cli.trigger_dag(self.parser.parse_args([\n 'dags', 'trigger', 'example_bash_operator',\n '-c', '{\"foo\": \"bar\"}']))\n self.assertRaises(\n ValueError,\n cli.trigger_dag,\n self.parser.parse_args([\n 'dags', 'trigger', 'example_bash_operator',\n '--run_id', 'trigger_dag_xxx',\n '-c', 'NOT JSON'])\n )\n\n def test_delete_dag(self):\n DM = DagModel\n key = \"my_dag_id\"\n session = settings.Session()\n session.add(DM(dag_id=key))\n session.commit()\n cli.delete_dag(self.parser.parse_args([\n 'dags', 'delete', key, '--yes']))\n self.assertEqual(session.query(DM).filter_by(dag_id=key).count(), 0)\n self.assertRaises(\n AirflowException,\n cli.delete_dag,\n self.parser.parse_args([\n 'dags', 'delete',\n 'does_not_exist_dag',\n '--yes'])\n )\n\n def test_pool_create(self):\n cli.pool_set(self.parser.parse_args(['pools', 'set', 'foo', '1', 'test']))\n self.assertEqual(self.session.query(Pool).count(), 1)\n\n def test_pool_get(self):\n cli.pool_set(self.parser.parse_args(['pools', 'set', 'foo', '1', 'test']))\n try:\n cli.pool_get(self.parser.parse_args(['pools', 'get', 'foo']))\n except Exception as e:\n self.fail(\"The 'pool -g foo' command raised unexpectedly: %s\" % e)\n\n def test_pool_delete(self):\n cli.pool_set(self.parser.parse_args(['pools', 'set', 'foo', '1', 'test']))\n cli.pool_delete(self.parser.parse_args(['pools', 'delete', 'foo']))\n self.assertEqual(self.session.query(Pool).count(), 0)\n\n def test_pool_import_export(self):\n # Create two pools first\n pool_config_input = {\n \"foo\": {\n \"description\": \"foo_test\",\n \"slots\": 1\n },\n \"baz\": {\n \"description\": \"baz_test\",\n \"slots\": 2\n }\n }\n with open('pools_import.json', mode='w') as file:\n json.dump(pool_config_input, file)\n\n # Import json\n try:\n cli.pool_import(self.parser.parse_args(['pools', 'import', 'pools_import.json']))\n except Exception as e:\n self.fail(\"The 'pool import pools_import.json' failed: %s\" % e)\n\n # Export json\n try:\n cli.pool_export(self.parser.parse_args(['pools', 'export', 'pools_export.json']))\n except Exception as e:\n self.fail(\"The 'pool export pools_export.json' failed: %s\" % e)\n\n with open('pools_export.json', mode='r') as file:\n pool_config_output = json.load(file)\n self.assertEqual(\n pool_config_input,\n pool_config_output,\n \"Input and output pool files are not same\")\n os.remove('pools_import.json')\n os.remove('pools_export.json')\n\n def test_variables(self):\n # Checks if all subcommands are properly received\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'foo', '{\"foo\":\"bar\"}']))\n cli.variables_get(self.parser.parse_args([\n 'variables', 'get', 'foo']))\n cli.variables_get(self.parser.parse_args([\n 'variables', 'get', 'baz', '-d', 'bar']))\n cli.variables_list(self.parser.parse_args([\n 'variables', 'list']))\n cli.variables_delete(self.parser.parse_args([\n 'variables', 'delete', 'bar']))\n cli.variables_import(self.parser.parse_args([\n 'variables', 'import', DEV_NULL]))\n cli.variables_export(self.parser.parse_args([\n 'variables', 'export', DEV_NULL]))\n\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'bar', 'original']))\n # First export\n cli.variables_export(self.parser.parse_args([\n 'variables', 'export', 'variables1.json']))\n\n first_exp = open('variables1.json', 'r')\n\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'bar', 'updated']))\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'foo', '{\"foo\":\"oops\"}']))\n cli.variables_delete(self.parser.parse_args([\n 'variables', 'delete', 'foo']))\n # First import\n cli.variables_import(self.parser.parse_args([\n 'variables', 'import', 'variables1.json']))\n\n self.assertEqual('original', Variable.get('bar'))\n self.assertEqual('{\\n \"foo\": \"bar\"\\n}', Variable.get('foo'))\n # Second export\n cli.variables_export(self.parser.parse_args([\n 'variables', 'export', 'variables2.json']))\n\n second_exp = open('variables2.json', 'r')\n self.assertEqual(first_exp.read(), second_exp.read())\n second_exp.close()\n first_exp.close()\n # Second import\n cli.variables_import(self.parser.parse_args([\n 'variables', 'import', 'variables2.json']))\n\n self.assertEqual('original', Variable.get('bar'))\n self.assertEqual('{\\n \"foo\": \"bar\"\\n}', Variable.get('foo'))\n\n # Set a dict\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'dict', '{\"foo\": \"oops\"}']))\n # Set a list\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'list', '[\"oops\"]']))\n # Set str\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'str', 'hello string']))\n # Set int\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'int', '42']))\n # Set float\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'float', '42.0']))\n # Set true\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'true', 'true']))\n # Set false\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'false', 'false']))\n # Set none\n cli.variables_set(self.parser.parse_args([\n 'variables', 'set', 'null', 'null']))\n\n # Export and then import\n cli.variables_export(self.parser.parse_args([\n 'variables', 'export', 'variables3.json']))\n cli.variables_import(self.parser.parse_args([\n 'variables', 'import', 'variables3.json']))\n\n # Assert value\n self.assertEqual({'foo': 'oops'}, models.Variable.get('dict', deserialize_json=True))\n self.assertEqual(['oops'], models.Variable.get('list', deserialize_json=True))\n self.assertEqual('hello string', models.Variable.get('str')) # cannot json.loads(str)\n self.assertEqual(42, models.Variable.get('int', deserialize_json=True))\n self.assertEqual(42.0, models.Variable.get('float', deserialize_json=True))\n self.assertEqual(True, models.Variable.get('true', deserialize_json=True))\n self.assertEqual(False, models.Variable.get('false', deserialize_json=True))\n self.assertEqual(None, models.Variable.get('null', deserialize_json=True))\n\n os.remove('variables1.json')\n os.remove('variables2.json')\n os.remove('variables3.json')\n\n def _wait_pidfile(self, pidfile):\n while True:\n try:\n with open(pidfile) as file:\n return int(file.read())\n except Exception:\n sleep(1)\n\n def test_cli_webserver_foreground(self):\n # Confirm that webserver hasn't been launched.\n # pgrep returns exit status 1 if no process matched.\n self.assertEqual(1, subprocess.Popen([\"pgrep\", \"-c\", \"airflow\"]).wait())\n self.assertEqual(1, subprocess.Popen([\"pgrep\", \"-c\", \"gunicorn\"]).wait())\n\n # Run webserver in foreground and terminate it.\n p = subprocess.Popen([\"airflow\", \"webserver\"])\n p.terminate()\n p.wait()\n\n # Assert that no process remains.\n self.assertEqual(1, subprocess.Popen([\"pgrep\", \"-c\", \"airflow\"]).wait())\n self.assertEqual(1, subprocess.Popen([\"pgrep\", \"-c\", \"gunicorn\"]).wait())\n\n @unittest.skipIf(\"TRAVIS\" in os.environ and bool(os.environ[\"TRAVIS\"]),\n \"Skipping test due to lack of required file permission\")\n def test_cli_webserver_foreground_with_pid(self):\n # Run webserver in foreground with --pid option\n pidfile = tempfile.mkstemp()[1]\n p = subprocess.Popen([\"airflow\", \"webserver\", \"--pid\", pidfile])\n\n # Check the file specified by --pid option exists\n self._wait_pidfile(pidfile)\n\n # Terminate webserver\n p.terminate()\n p.wait()\n\n @unittest.skipIf(\"TRAVIS\" in os.environ and bool(os.environ[\"TRAVIS\"]),\n \"Skipping test due to lack of required file permission\")\n def test_cli_webserver_background(self):\n import psutil\n\n # Confirm that webserver hasn't been launched.\n self.assertEqual(1, subprocess.Popen([\"pgrep\", \"-c\", \"airflow\"]).wait())\n self.assertEqual(1, subprocess.Popen([\"pgrep\", \"-c\", \"gunicorn\"]).wait())\n\n # Run webserver in background.\n subprocess.Popen([\"airflow\", \"webserver\", \"-D\"])\n pidfile = cli.setup_locations(\"webserver\")[0]\n self._wait_pidfile(pidfile)\n\n # Assert that gunicorn and its monitor are launched.\n self.assertEqual(0, subprocess.Popen([\"pgrep\", \"-c\", \"airflow\"]).wait())\n self.assertEqual(0, subprocess.Popen([\"pgrep\", \"-c\", \"gunicorn\"]).wait())\n\n # Terminate monitor process.\n pidfile = cli.setup_locations(\"webserver-monitor\")[0]\n pid = self._wait_pidfile(pidfile)\n p = psutil.Process(pid)\n p.terminate()\n p.wait()\n\n # Assert that no process remains.\n self.assertEqual(1, subprocess.Popen([\"pgrep\", \"-c\", \"airflow\"]).wait())\n self.assertEqual(1, subprocess.Popen([\"pgrep\", \"-c\", \"gunicorn\"]).wait())\n\n # Patch for causing webserver timeout\n @mock.patch(\"airflow.bin.cli.get_num_workers_running\", return_value=0)\n def test_cli_webserver_shutdown_when_gunicorn_master_is_killed(self, _):\n # Shorten timeout so that this test doesn't take too long time\n args = self.parser.parse_args(['webserver'])\n with conf_vars({('webserver', 'web_server_master_timeout'): '10'}):\n with self.assertRaises(SystemExit) as e:\n cli.webserver(args)\n self.assertEqual(e.exception.code, 1)\n\n\nclass FakeWebHDFSHook:\n def __init__(self, conn_id):\n self.conn_id = conn_id\n\n def get_conn(self):\n return self.conn_id\n\n def check_for_path(self, hdfs_path):\n return hdfs_path\n\n\nclass FakeSnakeBiteClientException(Exception):\n pass\n\n\nclass FakeSnakeBiteClient:\n\n def __init__(self):\n self.started = True\n\n def ls(self, path, include_toplevel=False):\n \"\"\"\n the fake snakebite client\n :param path: the array of path to test\n :param include_toplevel: to return the toplevel directory info\n :return: a list for path for the matching queries\n \"\"\"\n if path[0] == '/datadirectory/empty_directory' and not include_toplevel:\n return []\n elif path[0] == '/datadirectory/datafile':\n return [{\n 'group': 'supergroup',\n 'permission': 420,\n 'file_type': 'f',\n 'access_time': 1481122343796,\n 'block_replication': 3,\n 'modification_time': 1481122343862,\n 'length': 0,\n 'blocksize': 134217728,\n 'owner': 'hdfs',\n 'path': '/datadirectory/datafile'\n }]\n elif path[0] == '/datadirectory/empty_directory' and include_toplevel:\n return [{\n 'group': 'supergroup',\n 'permission': 493,\n 'file_type': 'd',\n 'access_time': 0,\n 'block_replication': 0,\n 'modification_time': 1481132141540,\n 'length': 0,\n 'blocksize': 0,\n 'owner': 'hdfs',\n 'path': '/datadirectory/empty_directory'\n }]\n elif path[0] == '/datadirectory/not_empty_directory' and include_toplevel:\n return [{\n 'group': 'supergroup',\n 'permission': 493,\n 'file_type': 'd',\n 'access_time': 0,\n 'block_replication': 0,\n 'modification_time': 1481132141540,\n 'length': 0,\n 'blocksize': 0,\n 'owner': 'hdfs',\n 'path': '/datadirectory/empty_directory'\n }, {\n 'group': 'supergroup',\n 'permission': 420,\n 'file_type': 'f',\n 'access_time': 1481122343796,\n 'block_replication': 3,\n 'modification_time': 1481122343862,\n 'length': 0,\n 'blocksize': 134217728,\n 'owner': 'hdfs',\n 'path': '/datadirectory/not_empty_directory/test_file'\n }]\n elif path[0] == '/datadirectory/not_empty_directory':\n return [{\n 'group': 'supergroup',\n 'permission': 420,\n 'file_type': 'f',\n 'access_time': 1481122343796,\n 'block_replication': 3,\n 'modification_time': 1481122343862,\n 'length': 0,\n 'blocksize': 134217728,\n 'owner': 'hdfs',\n 'path': '/datadirectory/not_empty_directory/test_file'\n }]\n elif path[0] == '/datadirectory/not_existing_file_or_directory':\n raise FakeSnakeBiteClientException\n elif path[0] == '/datadirectory/regex_dir':\n return [{\n 'group': 'supergroup',\n 'permission': 420,\n 'file_type': 'f',\n 'access_time': 1481122343796,\n 'block_replication': 3,\n 'modification_time': 1481122343862, 'length': 12582912,\n 'blocksize': 134217728,\n 'owner': 'hdfs',\n 'path': '/datadirectory/regex_dir/test1file'\n }, {\n 'group': 'supergroup',\n 'permission': 420,\n 'file_type': 'f',\n 'access_time': 1481122343796,\n 'block_replication': 3,\n 'modification_time': 1481122343862,\n 'length': 12582912,\n 'blocksize': 134217728,\n 'owner': 'hdfs',\n 'path': '/datadirectory/regex_dir/test2file'\n }, {\n 'group': 'supergroup',\n 'permission': 420,\n 'file_type': 'f',\n 'access_time': 1481122343796,\n 'block_replication': 3,\n 'modification_time': 1481122343862,\n 'length': 12582912,\n 'blocksize': 134217728,\n 'owner': 'hdfs',\n 'path': '/datadirectory/regex_dir/test3file'\n }, {\n 'group': 'supergroup',\n 'permission': 420,\n 'file_type': 'f',\n 'access_time': 1481122343796,\n 'block_replication': 3,\n 'modification_time': 1481122343862,\n 'length': 12582912,\n 'blocksize': 134217728,\n 'owner': 'hdfs',\n 'path': '/datadirectory/regex_dir/copying_file_1.txt._COPYING_'\n }, {\n 'group': 'supergroup',\n 'permission': 420,\n 'file_type': 'f',\n 'access_time': 1481122343796,\n 'block_replication': 3,\n 'modification_time': 1481122343862,\n 'length': 12582912,\n 'blocksize': 134217728,\n 'owner': 'hdfs',\n 'path': '/datadirectory/regex_dir/copying_file_3.txt.sftp'\n }]\n else:\n raise FakeSnakeBiteClientException\n\n\nclass FakeHDFSHook:\n def __init__(self, conn_id=None):\n self.conn_id = conn_id\n\n def get_conn(self):\n client = FakeSnakeBiteClient()\n return client\n\n\nclass TestConnection(unittest.TestCase):\n def setUp(self):\n utils.db.initdb()\n os.environ['AIRFLOW_CONN_TEST_URI'] = (\n 'postgres://username:password@ec2.compute.com:5432/the_database')\n os.environ['AIRFLOW_CONN_TEST_URI_NO_CREDS'] = (\n 'postgres://ec2.compute.com/the_database')\n\n def tearDown(self):\n env_vars = ['AIRFLOW_CONN_TEST_URI', 'AIRFLOW_CONN_AIRFLOW_DB']\n for ev in env_vars:\n if ev in os.environ:\n del os.environ[ev]\n\n def test_using_env_var(self):\n c = SqliteHook.get_connection(conn_id='test_uri')\n self.assertEqual('ec2.compute.com', c.host)\n self.assertEqual('the_database', c.schema)\n self.assertEqual('username', c.login)\n self.assertEqual('password', c.password)\n self.assertEqual(5432, c.port)\n\n def test_using_unix_socket_env_var(self):\n c = SqliteHook.get_connection(conn_id='test_uri_no_creds')\n self.assertEqual('ec2.compute.com', c.host)\n self.assertEqual('the_database', c.schema)\n self.assertIsNone(c.login)\n self.assertIsNone(c.password)\n self.assertIsNone(c.port)\n\n def test_param_setup(self):\n c = Connection(conn_id='local_mysql', conn_type='mysql',\n host='localhost', login='airflow',\n password='airflow', schema='airflow')\n self.assertEqual('localhost', c.host)\n self.assertEqual('airflow', c.schema)\n self.assertEqual('airflow', c.login)\n self.assertEqual('airflow', c.password)\n self.assertIsNone(c.port)\n\n def test_env_var_priority(self):\n c = SqliteHook.get_connection(conn_id='airflow_db')\n self.assertNotEqual('ec2.compute.com', c.host)\n\n os.environ['AIRFLOW_CONN_AIRFLOW_DB'] = \\\n 'postgres://username:password@ec2.compute.com:5432/the_database'\n c = SqliteHook.get_connection(conn_id='airflow_db')\n self.assertEqual('ec2.compute.com', c.host)\n self.assertEqual('the_database', c.schema)\n self.assertEqual('username', c.login)\n self.assertEqual('password', c.password)\n self.assertEqual(5432, c.port)\n del os.environ['AIRFLOW_CONN_AIRFLOW_DB']\n\n def test_dbapi_get_uri(self):\n conn = BaseHook.get_connection(conn_id='test_uri')\n hook = conn.get_hook()\n self.assertEqual('postgres://username:password@ec2.compute.com:5432/the_database', hook.get_uri())\n conn2 = BaseHook.get_connection(conn_id='test_uri_no_creds')\n hook2 = conn2.get_hook()\n self.assertEqual('postgres://ec2.compute.com/the_database', hook2.get_uri())\n\n def test_dbapi_get_sqlalchemy_engine(self):\n conn = BaseHook.get_connection(conn_id='test_uri')\n hook = conn.get_hook()\n engine = hook.get_sqlalchemy_engine()\n self.assertIsInstance(engine, sqlalchemy.engine.Engine)\n self.assertEqual('postgres://username:password@ec2.compute.com:5432/the_database', str(engine.url))\n\n def test_get_connections_env_var(self):\n conns = SqliteHook.get_connections(conn_id='test_uri')\n assert len(conns) == 1\n assert conns[0].host == 'ec2.compute.com'\n assert conns[0].schema == 'the_database'\n assert conns[0].login == 'username'\n assert conns[0].password == 'password'\n assert conns[0].port == 5432\n\n\nclass TestWebHDFSHook(unittest.TestCase):\n def test_simple_init(self):\n from airflow.hooks.webhdfs_hook import WebHDFSHook\n c = WebHDFSHook()\n self.assertIsNone(c.proxy_user)\n\n def test_init_proxy_user(self):\n from airflow.hooks.webhdfs_hook import WebHDFSHook\n c = WebHDFSHook(proxy_user='someone')\n self.assertEqual('someone', c.proxy_user)\n\n\nHDFSHook = None # type: Optional[hdfs_hook.HDFSHook]\nsnakebite = None # type: None\n\n\n@unittest.skipIf(HDFSHook is None,\n \"Skipping test because HDFSHook is not installed\")\nclass TestHDFSHook(unittest.TestCase):\n def setUp(self):\n os.environ['AIRFLOW_CONN_HDFS_DEFAULT'] = 'hdfs://localhost:8020'\n\n def test_get_client(self):\n client = HDFSHook(proxy_user='foo').get_conn()\n self.assertIsInstance(client, snakebite.client.Client)\n self.assertEqual('localhost', client.host)\n self.assertEqual(8020, client.port)\n self.assertEqual('foo', client.service.channel.effective_user)\n\n @mock.patch('airflow.hooks.hdfs_hook.AutoConfigClient')\n @mock.patch('airflow.hooks.hdfs_hook.HDFSHook.get_connections')\n def test_get_autoconfig_client(self, mock_get_connections,\n MockAutoConfigClient):\n c = Connection(conn_id='hdfs', conn_type='hdfs',\n host='localhost', port=8020, login='foo',\n extra=json.dumps({'autoconfig': True}))\n mock_get_connections.return_value = [c]\n HDFSHook(hdfs_conn_id='hdfs').get_conn()\n MockAutoConfigClient.assert_called_once_with(effective_user='foo',\n use_sasl=False)\n\n @mock.patch('airflow.hooks.hdfs_hook.AutoConfigClient')\n def test_get_autoconfig_client_no_conn(self, MockAutoConfigClient):\n HDFSHook(hdfs_conn_id='hdfs_missing', autoconfig=True).get_conn()\n MockAutoConfigClient.assert_called_once_with(effective_user=None,\n use_sasl=False)\n\n @mock.patch('airflow.hooks.hdfs_hook.HDFSHook.get_connections')\n def test_get_ha_client(self, mock_get_connections):\n c1 = Connection(conn_id='hdfs_default', conn_type='hdfs',\n host='localhost', port=8020)\n c2 = Connection(conn_id='hdfs_default', conn_type='hdfs',\n host='localhost2', port=8020)\n mock_get_connections.return_value = [c1, c2]\n client = HDFSHook().get_conn()\n self.assertIsInstance(client, snakebite.client.HAClient)\n\n\nsend_email_test = mock.Mock()\n\n\nclass TestEmail(unittest.TestCase):\n def setUp(self):\n conf.remove_option('email', 'EMAIL_BACKEND')\n\n @mock.patch('airflow.utils.email.send_email')\n def test_default_backend(self, mock_send_email):\n res = utils.email.send_email('to', 'subject', 'content')\n mock_send_email.assert_called_once_with('to', 'subject', 'content')\n self.assertEqual(mock_send_email.return_value, res)\n\n @mock.patch('airflow.utils.email.send_email_smtp')\n def test_custom_backend(self, mock_send_email):\n with conf_vars({('email', 'email_backend'): 'tests.core.send_email_test'}):\n utils.email.send_email('to', 'subject', 'content')\n send_email_test.assert_called_once_with(\n 'to', 'subject', 'content', files=None, dryrun=False,\n cc=None, bcc=None, mime_charset='utf-8', mime_subtype='mixed')\n self.assertFalse(mock_send_email.called)\n\n\nclass TestEmailSmtp(unittest.TestCase):\n def setUp(self):\n conf.set('smtp', 'SMTP_SSL', 'False')\n\n @mock.patch('airflow.utils.email.send_MIME_email')\n def test_send_smtp(self, mock_send_mime):\n attachment = tempfile.NamedTemporaryFile()\n attachment.write(b'attachment')\n attachment.seek(0)\n utils.email.send_email_smtp('to', 'subject', 'content', files=[attachment.name])\n self.assertTrue(mock_send_mime.called)\n call_args = mock_send_mime.call_args[0]\n self.assertEqual(conf.get('smtp', 'SMTP_MAIL_FROM'), call_args[0])\n self.assertEqual(['to'], call_args[1])\n msg = call_args[2]\n self.assertEqual('subject', msg['Subject'])\n self.assertEqual(conf.get('smtp', 'SMTP_MAIL_FROM'), msg['From'])\n self.assertEqual(2, len(msg.get_payload()))\n filename = 'attachment; filename=\"' + os.path.basename(attachment.name) + '\"'\n self.assertEqual(filename, msg.get_payload()[-1].get('Content-Disposition'))\n mimeapp = MIMEApplication('attachment')\n self.assertEqual(mimeapp.get_payload(), msg.get_payload()[-1].get_payload())\n\n @mock.patch('airflow.utils.email.send_MIME_email')\n def test_send_smtp_with_multibyte_content(self, mock_send_mime):\n utils.email.send_email_smtp('to', 'subject', '🔥', mime_charset='utf-8')\n self.assertTrue(mock_send_mime.called)\n call_args = mock_send_mime.call_args[0]\n msg = call_args[2]\n mimetext = MIMEText('🔥', 'mixed', 'utf-8')\n self.assertEqual(mimetext.get_payload(), msg.get_payload()[0].get_payload())\n\n @mock.patch('airflow.utils.email.send_MIME_email')\n def test_send_bcc_smtp(self, mock_send_mime):\n attachment = tempfile.NamedTemporaryFile()\n attachment.write(b'attachment')\n attachment.seek(0)\n utils.email.send_email_smtp('to', 'subject', 'content', files=[attachment.name], cc='cc', bcc='bcc')\n self.assertTrue(mock_send_mime.called)\n call_args = mock_send_mime.call_args[0]\n self.assertEqual(conf.get('smtp', 'SMTP_MAIL_FROM'), call_args[0])\n self.assertEqual(['to', 'cc', 'bcc'], call_args[1])\n msg = call_args[2]\n self.assertEqual('subject', msg['Subject'])\n self.assertEqual(conf.get('smtp', 'SMTP_MAIL_FROM'), msg['From'])\n self.assertEqual(2, len(msg.get_payload()))\n self.assertEqual('attachment; filename=\"' + os.path.basename(attachment.name) + '\"',\n msg.get_payload()[-1].get('Content-Disposition'))\n mimeapp = MIMEApplication('attachment')\n self.assertEqual(mimeapp.get_payload(), msg.get_payload()[-1].get_payload())\n\n @mock.patch('smtplib.SMTP_SSL')\n @mock.patch('smtplib.SMTP')\n def test_send_mime(self, mock_smtp, mock_smtp_ssl):\n mock_smtp.return_value = mock.Mock()\n mock_smtp_ssl.return_value = mock.Mock()\n msg = MIMEMultipart()\n utils.email.send_MIME_email('from', 'to', msg, dryrun=False)\n mock_smtp.assert_called_once_with(\n conf.get('smtp', 'SMTP_HOST'),\n conf.getint('smtp', 'SMTP_PORT'),\n )\n self.assertTrue(mock_smtp.return_value.starttls.called)\n mock_smtp.return_value.login.assert_called_once_with(\n conf.get('smtp', 'SMTP_USER'),\n conf.get('smtp', 'SMTP_PASSWORD'),\n )\n mock_smtp.return_value.sendmail.assert_called_once_with('from', 'to', msg.as_string())\n self.assertTrue(mock_smtp.return_value.quit.called)\n\n @mock.patch('smtplib.SMTP_SSL')\n @mock.patch('smtplib.SMTP')\n def test_send_mime_ssl(self, mock_smtp, mock_smtp_ssl):\n mock_smtp.return_value = mock.Mock()\n mock_smtp_ssl.return_value = mock.Mock()\n with conf_vars({('smtp', 'smtp_ssl'): 'True'}):\n utils.email.send_MIME_email('from', 'to', MIMEMultipart(), dryrun=False)\n self.assertFalse(mock_smtp.called)\n mock_smtp_ssl.assert_called_once_with(\n conf.get('smtp', 'SMTP_HOST'),\n conf.getint('smtp', 'SMTP_PORT'),\n )\n\n @mock.patch('smtplib.SMTP_SSL')\n @mock.patch('smtplib.SMTP')\n def test_send_mime_noauth(self, mock_smtp, mock_smtp_ssl):\n mock_smtp.return_value = mock.Mock()\n mock_smtp_ssl.return_value = mock.Mock()\n with conf_vars({\n ('smtp', 'smtp_user'): None,\n ('smtp', 'smtp_password'): None,\n }):\n utils.email.send_MIME_email('from', 'to', MIMEMultipart(), dryrun=False)\n self.assertFalse(mock_smtp_ssl.called)\n mock_smtp.assert_called_once_with(\n conf.get('smtp', 'SMTP_HOST'),\n conf.getint('smtp', 'SMTP_PORT'),\n )\n self.assertFalse(mock_smtp.login.called)\n\n @mock.patch('smtplib.SMTP_SSL')\n @mock.patch('smtplib.SMTP')\n def test_send_mime_dryrun(self, mock_smtp, mock_smtp_ssl):\n utils.email.send_MIME_email('from', 'to', MIMEMultipart(), dryrun=True)\n self.assertFalse(mock_smtp.called)\n self.assertFalse(mock_smtp_ssl.called)\n\n\nif __name__ == '__main__':\n unittest.main()\n"
] |
[
[
"numpy.testing.assert_array_almost_equal"
]
] |
Mhaiyang/iccv
|
[
"04a8ee52c2323d7ff5cdf03c0be1466e8180d2eb"
] |
[
"utils/pascal.py"
] |
[
"\"\"\"\n @Time : 203/10/19 15:31\n @Author : TaylorMei\n @Email : mhy845879017@gmail.com\n \n @Project : iccv\n @File : pascal.py\n @Function:\n \n\"\"\"\nimport os\nimport numpy as np\nimport skimage.io\n\ninput_path = \"/home/iccd/data/MSRA10K/PASCAL-S/masks/\"\noutput_path = \"/home/iccd/data/MSRA10K/PASCAL-S/mask/\"\n\nimglist = os.listdir(input_path)\nfor i, imgname in enumerate(imglist):\n print(i, imgname)\n mask = skimage.io.imread(input_path + imgname)\n print(np.max(mask))\n mask = np.where(mask >= 127.5, 255, 0).astype(np.uint8)\n mask = skimage.io.imsave(output_path + imgname, mask)\n"
] |
[
[
"numpy.max",
"numpy.where"
]
] |
spencerkent/vision-transform-codes
|
[
"63258ce698e436ee3ce29def75c89337759fb98b",
"63258ce698e436ee3ce29def75c89337759fb98b"
] |
[
"vision_transform_codes/tests/sparse_coding_2.py",
"vision_transform_codes/training/ica.py"
] |
[
"\"\"\"\nTest: Sparse coding, fully connected, fista, cheap qaudratic descent\n\"\"\"\nimport _set_the_path\n\nimport math\nimport pickle\nimport torch\n\nfrom training.sparse_coding import train_dictionary\nfrom utils.dataset_generation import OneOutputDset\nfrom utils import defaults\n\nRUN_IDENTIFIER = '_testing_sc_2'\nLOGS_STORED_HERE = defaults.logging_directory\n\nTRAINING_SET_SIZE = 10000\nVALIDATION_SET_SIZE = 5000\nBATCH_SIZE = 1000\nPATCH_HEIGHT = 16\nPATCH_WIDTH = 16\n\nCODE_SIZE = 1 * PATCH_HEIGHT*PATCH_WIDTH # critically sampled\nNUM_EPOCHS = 1\niters_per_epoch = int(math.ceil(TRAINING_SET_SIZE / BATCH_SIZE))\n\ntrn_val_dsets = pickle.load(open(defaults.dataset_directory /\n 'vtc_testing/field_white_16x16.p', 'rb'))\n\nSC_PARAMS = {\n 'mode': 'fully-connected',\n 'num_epochs': NUM_EPOCHS,\n 'code_inference_algorithm': 'fista',\n 'inference_param_schedule': {\n 0: {'sparsity_weight': 0.008, 'num_iters': 5}},\n 'dictionary_update_algorithm': 'sc_cheap_quadratic_descent',\n 'dict_update_param_schedule': {\n 0: {'stepsize': 0.1, 'num_iters': 1},\n 5*iters_per_epoch: {'stepsize': 0.05, 'num_iters': 1}},\n # write various tensorboard logs on the following schedule:\n 'training_visualization_schedule': set([0, 10, 500]),\n 'reshaped_kernel_size': (PATCH_HEIGHT, PATCH_WIDTH),\n # actually store all logs here:\n 'logging_folder_fullpath': LOGS_STORED_HERE / RUN_IDENTIFIER,\n # checkpoint the dictionary on this interval\n 'checkpoint_schedule': set([iters_per_epoch,\n (NUM_EPOCHS*iters_per_epoch)-1])}\nSC_PARAMS['training_visualization_schedule'].update(set(\n [iters_per_epoch*x for x in range(1, NUM_EPOCHS)]))\n\n\n# Now initialize model and begin training\ntorch_device = torch.device('cuda:1')\n# otherwise can put on 'cuda:0' or 'cpu'\n\n# send ALL image patches to the GPU and wrap in a simple dataloader\nimage_patches_gpu_training = torch.utils.data.DataLoader(\n OneOutputDset(torch.from_numpy(\n trn_val_dsets['training']['patches']).to(torch_device)),\n batch_size=BATCH_SIZE, shuffle=True)\nimage_patches_gpu_validation = torch.utils.data.DataLoader(\n OneOutputDset(torch.from_numpy(\n trn_val_dsets['validation']['patches']).to(torch_device)),\n batch_size=BATCH_SIZE*10) # larger batches for validation data\n# if data is too big to all fit on GPU, just omit .to(torch_device) above.\n# Can also add num_workers=x to the DataLoader constructor\n\n# create the dictionary Tensor on the GPU\nsparse_coding_dictionary = torch.randn((CODE_SIZE, PATCH_HEIGHT*PATCH_WIDTH),\n device=torch_device)\n# start out the dictionaries with norm 1\nsparse_coding_dictionary.div_(\n sparse_coding_dictionary.norm(p=2, dim=1)[:, None])\n\ntrain_dictionary(image_patches_gpu_training, image_patches_gpu_validation,\n sparse_coding_dictionary, SC_PARAMS)\n",
"\"\"\"\nThis implements ICA dictionary learning\n\"\"\"\n\nimport time\nimport os\nimport pickle\nimport yaml\nfrom matplotlib import pyplot as plt\nimport torch\n\ndef train_dictionary(image_dataset, init_dictionary, all_params):\n \"\"\"\n Train an ICA dictionary\n\n Only works in 'fully-connected' mode\n\n Parameters\n ----------\n image_dataset : torch.Tensor OR torch.Dataloader\n We make __getitem__ calls to either of these iterables and have them\n return us a batch of images. If image_dataset is a torch Tensor, that\n means ALL of the data is stored in the CPU's RAM or in the GPU's RAM. The\n choice of which will have already been made when the Tensor is created.\n The tensor is an array of size (k, b, n) where k is the total number of\n batches, n is the (flattened) size of each image, and b is the size of\n an individual batch. If image_dataset is a torch.DataLoader that means\n each time we make a __getitem__ call it will return a batch of images\n that it has fetched and preprocessed from disk. This is done in cpu\n multiprocesses that run asynchronously from the GPU. If the whole dataset\n is too large to be loaded into memory, this is really our only option.\n init_dictionary : torch.Tensor(float32, size=(n, n))\n This is an initial guess for the dictionary of basis functions that\n we can use to descibe the images. n is the size of each image and also\n the size of the code -- in ICA the codes are always the same\n dimensionality as the input signal.\n all_params :\n --- MANDATORY ---\n 'num_epochs': int\n The number of times to cycle over the whole dataset, reshuffling the\n order of the patches.\n 'dictionary_update_algorithm' : str\n One of {'ica_natural_gradient'}\n 'dict_update_param_schedule' : dictionary\n Dictionary containing iteration indexes at which to set/update\n parameters of the dictionary update algorithm. This will be algorithm\n specific. See the docstring for the respective algorithm in\n dictionary_learning/\n --- OPTIONAL ---\n 'checkpoint_schedule' : dictionary, optional\n Specific iterations at which to save the\n parameters of the model (dictionary, codes, etc.) to disk. Values\n associated w/ each of these keys aren't used and can be set to None.\n We're just using the dictionary for its fast hash-based lookup.\n 'training_visualization_schedule' : dictionary, optional\n Specific iterations at which to plot the dictionary and some sample\n codes. Again, dictionary values can be None, we're just using the keys\n 'logging_folder_fullpath' : pathlib.Path, optional\n Tells us where to save any checkpoint files or tensorboard summaries.\n Required if either 'checkpoint_schedule' or\n 'training_visualization_schedule' is set.\n 'stdout_print_interval' : int, optional\n The interval on which we print training progress to the terminal.\n Default 1000.\n \"\"\"\n ################################\n # Visualization Helper functions\n ################################\n def save_checkpoint(where_to_save):\n # In lieu of the torch-specific saver torch.save, we'll just use\n # pythons's standard serialization tool, pickle. That way we can mess\n # with the results without needing PyTorch.\n pickle.dump(dictionary.cpu().numpy(), open(where_to_save, 'wb'))\n\n def log_training_progress(current_iteration_number):\n batch_images_np = batch_images.cpu().numpy()\n batch_sig_mag = np.max(batch_images_np) - np.min(batch_images_np)\n #^ psnr depends on the range of the data which we just estimate from\n # this batch.\n recons = torch.mm(codes, dictionary).cpu().numpy()\n recon_psnr = []\n for b_idx in range(recons.shape[0]):\n psnr = compute_pSNR(batch_images_np[b_idx, :],\n recons[b_idx, :], manual_sig_mag=batch_sig_mag)\n if psnr != np.inf:\n recon_psnr.append(psnr)\n avg_recon_psnr = np.mean(recon_psnr)\n # Tensorboard doesn't give you a lot of control for how images look so\n # i'm going to generate my own pyplot figures and save these as images.\n # There's probably a more elegant way to do this, but it works for now...\n tiled_kernel_figs = display_dictionary(\n dictionary.cpu().numpy(), reshaping=kernel_reshaping,\n renormalize=True,\n plot_title='Current dictionary (renormalized), iter{}'.format(\n total_iter_idx))\n for fig_idx in range(len(tiled_kernel_figs)):\n tb_img_caption = ('Current dictionary (renorm), fig ' + str(fig_idx+1) +\n ' of ' + str(len(tiled_kernel_figs)))\n write_pyplot_to_tb_image(tiled_kernel_figs[fig_idx], tb_img_caption)\n del tiled_kernel_figs\n tiled_kernel_figs = display_dictionary(\n dictionary.cpu().numpy(), reshaping=kernel_reshaping,\n renormalize=False,\n plot_title='Current dictionary (no renorm), iter {}'.format(\n total_iter_idx))\n for fig_idx in range(len(tiled_kernel_figs)):\n tb_img_caption = ('Current dictionary (no renorm), fig ' +\n str(fig_idx+1) + ' of ' + str(len(tiled_kernel_figs)))\n write_pyplot_to_tb_image(tiled_kernel_figs[fig_idx], tb_img_caption)\n del tiled_kernel_figs\n\n #TODO: plot the ICA cost function\n tb_summary_writer.add_scalar('Average pSNR of reconstructions',\n avg_recon_psnr, total_iter_idx)\n\n def write_pyplot_to_tb_image(plt_fig, img_caption):\n buf = io.BytesIO()\n plt_fig.savefig(buf, format='png')\n plt.close(plt_fig)\n the_tensor = torch.tensor(np.array(Image.open(buf))[:, :, :3])\n tb_summary_writer.add_image(img_caption,\n torch.tensor(np.array(Image.open(buf))[:, :, :3]),\n global_step=total_iter_idx, dataformats='HWC')\n ##########################\n # Done w/ helper functions\n ##########################\n\n ##########################\n # Setup and error checking\n ##########################\n assert 0 in all_params['dict_update_param_schedule']\n assert init_dictionary.size(0) == init_dictionary.size(1) # critically sample\n # let's unpack all_params to make things a little less verbose...\n ### MANDATORY ###\n num_epochs = all_params['num_epochs']\n dict_update_alg = all_params['dictionary_update_algorithm']\n dict_update_param_schedule = all_params['dict_update_param_schedule']\n assert dict_update_alg in ['ica_natural_gradient']\n ### OPTIONAL ###\n if 'logging_folder_fullpath' in all_params:\n assert type(all_params['logging_folder_fullpath']) != str, (\n 'should be pathlib.Path')\n logging_path = all_params['logging_folder_fullpath']\n if logging_path.exists() and ('checkpoint_schedule' in all_params or\n 'training_visualization_schedule' in all_params):\n print('-------\\n',\n 'Warning, saving checkpoints and/or tensorboard logs into ',\n 'existing, directory. Will overwrite existing files\\n-------')\n if not logging_path.exists() and ('checkpoint_schedule' in all_params or\n 'training_visualization_schedule' in all_params):\n logging_path.mkdir(parents=True)\n if 'checkpoint_schedule' in all_params:\n import os\n import pickle\n ckpt_sched = all_params['checkpoint_schedule']\n else:\n ckpt_sched = None\n if 'training_visualization_schedule' in all_params:\n import io\n import numpy as np\n from matplotlib import pyplot as plt\n from PIL import Image\n from utils.plotting import compute_pSNR\n from utils.plotting import display_dictionary\n from torch.utils.tensorboard import SummaryWriter\n trn_vis_sched = all_params['training_visualization_schedule']\n tb_summary_writer = SummaryWriter(logging_path)\n if 'reshaped_kernel_size' in all_params:\n kernel_reshaping = all_params.pop('reshaped_kernel_size')\n else:\n kernel_reshaping = None\n else:\n trn_vis_sched = None\n if ckpt_sched is not None or trn_vis_sched is not None:\n import yaml\n # dump the parameters of this training session in human-readable JSON\n saved_training_params = {\n k: all_params[k] for k in all_params if k not in\n ['checkpoint_schedule', 'training_visualization_schedule']}\n yaml.dump(saved_training_params,\n open(logging_path / 'training_params.yaml', 'w'))\n if 'stdout_print_interval' in all_params:\n print_interval = all_params['stdout_print_interval']\n else:\n print_interval = 1000\n\n from analysis_transforms.fully_connected import invertible_linear\n if dict_update_alg == 'ica_natural_gradient':\n from dict_update_rules.fully_connected import ica_natural_gradient\n else:\n raise KeyError('Unrecognized dict update algorithm: ' + dict_update_alg)\n ##################################\n # Done w/ setup and error checking\n ##################################\n\n dictionary = init_dictionary # no copying, just a new reference\n\n starttime = time.time()\n total_iter_idx = 0\n for epoch_idx in range(num_epochs):\n for batch_idx, batch_images in enumerate(image_dataset):\n ###########################\n # Status updates to console\n ###########################\n if total_iter_idx % print_interval == 0:\n print('Iteration', total_iter_idx, 'complete')\n print('Time elapsed:', '{:.1f}'.format(time.time() - starttime),\n 'seconds')\n print('-----')\n\n if dictionary.device != batch_images.device:\n batch_images = batch_images.to(dictionary.device)\n\n ####################\n # Run code inference\n ####################\n codes = invertible_linear.run(batch_images, dictionary)\n\n #################################\n # Checkpointing and visualization\n #################################\n if (ckpt_sched is not None and total_iter_idx in ckpt_sched):\n save_checkpoint(logging_path /\n ('checkpoint_dictionary_iter_' + str(total_iter_idx)))\n if (trn_vis_sched is not None and total_iter_idx in trn_vis_sched):\n log_training_progress(total_iter_idx)\n\n #######################\n # Update the dictionary\n #######################\n # check to see if we need to set/update parameters\n if total_iter_idx in dict_update_param_schedule:\n d_upd_stp= dict_update_param_schedule[total_iter_idx]['stepsize']\n d_upd_niters = dict_update_param_schedule[total_iter_idx]['num_iters']\n if dict_update_alg == 'ica_natural_gradient':\n ica_natural_gradient.run(dictionary, codes, d_upd_stp, d_upd_niters)\n\n total_iter_idx += 1\n\n print(\"Epoch\", epoch_idx, \"finished\")\n"
] |
[
[
"torch.device",
"torch.randn",
"torch.from_numpy"
],
[
"numpy.max",
"numpy.min",
"matplotlib.pyplot.close",
"numpy.mean",
"torch.mm",
"torch.utils.tensorboard.SummaryWriter"
]
] |
spacemig/satellite-attitude-simulator
|
[
"77ad4e05a4e8076aa1e5077023d0ee293ccc4530",
"77ad4e05a4e8076aa1e5077023d0ee293ccc4530"
] |
[
"thirdparty/pyorbital/orbital.py",
"modules/attitude.py"
] |
[
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n# Copyright (c) 2011, 2012, 2013, 2014, 2015.\n\n# Author(s):\n\n# Esben S. Nielsen <esn@dmi.dk>\n# Adam Dybbroe <adam.dybbroe@smhi.se>\n# Martin Raspaud <martin.raspaud@smhi.se>\n\n# This program is free software: you can redistribute it and/or modify\n# it under the terms of the GNU General Public License as published by\n# the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n\n# This program is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU General Public License for more details.\n\n# You should have received a copy of the GNU General Public License\n# along with this program. If not, see <http://www.gnu.org/licenses/>.\n\n\"\"\"Module for computing the orbital parameters of satellites.\"\"\"\n\nimport warnings\nfrom datetime import datetime, timedelta\n\nfrom scipy import optimize\n\nimport numpy as np\nfrom pyorbital import astronomy, dt2np, tlefile\n\ntry:\n import dask.array as da\n has_dask = True\nexcept ImportError:\n da = None\n has_dask = False\n\ntry:\n import xarray as xr\n has_xarray = True\nexcept ImportError:\n xr = None\n has_xarray = False\n\nECC_EPS = 1.0e-6 # Too low for computing further drops.\nECC_LIMIT_LOW = -1.0e-3\nECC_LIMIT_HIGH = 1.0 - ECC_EPS # Too close to 1\nECC_ALL = 1.0e-4\n\nEPS_COS = 1.5e-12\n\nNR_EPS = 1.0e-12\n\nCK2 = 5.413080e-4\nCK4 = 0.62098875e-6\nE6A = 1.0e-6\nQOMS2T = 1.88027916e-9\nS = 1.01222928\nS0 = 78.0\nXJ3 = -0.253881e-5\nXKE = 0.743669161e-1\nXKMPER = 6378.135\nXMNPDA = 1440.0\n# MFACTOR = 7.292115E-5\nAE = 1.0\nSECDAY = 8.6400E4\n\nF = 1 / 298.257223563 # Earth flattening WGS-84\nA = 6378.137 # WGS84 Equatorial radius\n\n\nSGDP4_ZERO_ECC = 0\nSGDP4_DEEP_NORM = 1\nSGDP4_NEAR_SIMP = 2\nSGDP4_NEAR_NORM = 3\n\nKS = AE * (1.0 + S0 / XKMPER)\nA3OVK2 = (-XJ3 / CK2) * AE**3\n\n\nclass OrbitalError(Exception):\n pass\n\n\ndef get_observer_look(sat_lon, sat_lat, sat_alt, utc_time, lon, lat, alt):\n \"\"\"Calculate observers look angle to a satellite.\n http://celestrak.com/columns/v02n02/\n\n :utc_time: Observation time (datetime object)\n :lon: Longitude of observer position on ground in degrees east\n :lat: Latitude of observer position on ground in degrees north\n :alt: Altitude above sea-level (geoid) of observer position on ground in km\n\n :return: (Azimuth, Elevation)\n \"\"\"\n (pos_x, pos_y, pos_z), (vel_x, vel_y, vel_z) = astronomy.observer_position(\n utc_time, sat_lon, sat_lat, sat_alt)\n\n (opos_x, opos_y, opos_z), (ovel_x, ovel_y, ovel_z) = \\\n astronomy.observer_position(utc_time, lon, lat, alt)\n\n lon = np.deg2rad(lon)\n lat = np.deg2rad(lat)\n\n theta = (astronomy.gmst(utc_time) + lon) % (2 * np.pi)\n\n rx = pos_x - opos_x\n ry = pos_y - opos_y\n rz = pos_z - opos_z\n\n sin_lat = np.sin(lat)\n cos_lat = np.cos(lat)\n sin_theta = np.sin(theta)\n cos_theta = np.cos(theta)\n\n top_s = sin_lat * cos_theta * rx + \\\n sin_lat * sin_theta * ry - cos_lat * rz\n top_e = -sin_theta * rx + cos_theta * ry\n top_z = cos_lat * cos_theta * rx + \\\n cos_lat * sin_theta * ry + sin_lat * rz\n\n az_ = np.arctan(-top_e / top_s)\n\n if has_xarray and isinstance(az_, xr.DataArray):\n az_data = az_.data\n else:\n az_data = az_\n\n if has_dask and isinstance(az_data, da.Array):\n az_data = da.where(top_s > 0, az_data + np.pi, az_data)\n az_data = da.where(az_data < 0, az_data + 2 * np.pi, az_data)\n else:\n az_data[np.where(top_s > 0)] += np.pi\n az_data[np.where(az_data < 0)] += 2 * np.pi\n\n if has_xarray and isinstance(az_, xr.DataArray):\n az_.data = az_data\n else:\n az_ = az_data\n\n rg_ = np.sqrt(rx * rx + ry * ry + rz * rz)\n el_ = np.arcsin(top_z / rg_)\n\n return np.rad2deg(az_), np.rad2deg(el_)\n\n\nclass Orbital(object):\n\n \"\"\"Class for orbital computations.\n\n The *satellite* parameter is the name of the satellite to work on and is\n used to retrieve the right TLE data for internet or from *tle_file* in case\n it is provided.\n \"\"\"\n\n def __init__(self, satellite, tle_file=None, line1=None, line2=None):\n satellite = satellite.upper()\n self.satellite_name = satellite\n self.tle = tlefile.read(satellite, tle_file=tle_file,\n line1=line1, line2=line2)\n self.orbit_elements = OrbitElements(self.tle)\n self._sgdp4 = _SGDP4(self.orbit_elements)\n\n def __str__(self):\n return self.satellite_name + \" \" + str(self.tle)\n\n def get_last_an_time(self, utc_time):\n \"\"\"Calculate time of last ascending node relative to the\n specified time\n \"\"\"\n\n # Propagate backwards to ascending node\n dt = np.timedelta64(10, 'm')\n t_old = utc_time\n t_new = t_old - dt\n pos0, vel0 = self.get_position(t_old, normalize=False)\n pos1, vel1 = self.get_position(t_new, normalize=False)\n while not (pos0[2] > 0 and pos1[2] < 0):\n pos0 = pos1\n t_old = t_new\n t_new = t_old - dt\n pos1, vel1 = self.get_position(t_new, normalize=False)\n\n # Return if z within 1 km of an\n if np.abs(pos0[2]) < 1:\n return t_old\n elif np.abs(pos1[2]) < 1:\n return t_new\n\n # Bisect to z within 1 km\n while np.abs(pos1[2]) > 1:\n # pos0, vel0 = pos1, vel1\n dt = (t_old - t_new) / 2\n t_mid = t_old - dt\n pos1, vel1 = self.get_position(t_mid, normalize=False)\n if pos1[2] > 0:\n t_old = t_mid\n else:\n t_new = t_mid\n\n return t_mid\n\n def get_position(self, utc_time, normalize=True):\n \"\"\"Get the cartesian position and velocity from the satellite.\n \"\"\"\n\n kep = self._sgdp4.propagate(utc_time)\n pos, vel = kep2xyz(kep)\n\n if normalize:\n pos /= XKMPER\n vel /= XKMPER * XMNPDA / SECDAY\n\n return pos, vel\n\n def get_lonlatalt(self, utc_time):\n \"\"\"Calculate sublon, sublat and altitude of satellite.\n http://celestrak.com/columns/v02n03/\n \"\"\"\n (pos_x, pos_y, pos_z), (vel_x, vel_y, vel_z) = self.get_position(\n utc_time, normalize=True)\n\n lon = ((np.arctan2(pos_y * XKMPER, pos_x * XKMPER) - astronomy.gmst(utc_time))\n % (2 * np.pi))\n\n lon = np.where(lon > np.pi, lon - np.pi * 2, lon)\n lon = np.where(lon <= -np.pi, lon + np.pi * 2, lon)\n\n r = np.sqrt(pos_x ** 2 + pos_y ** 2)\n lat = np.arctan2(pos_z, r)\n e2 = F * (2 - F)\n while True:\n lat2 = lat\n c = 1 / (np.sqrt(1 - e2 * (np.sin(lat2) ** 2)))\n lat = np.arctan2(pos_z + c * e2 * np.sin(lat2), r)\n if np.all(abs(lat - lat2) < 1e-10):\n break\n alt = r / np.cos(lat) - c\n alt *= A\n return np.rad2deg(lon), np.rad2deg(lat), alt\n\n def find_aos(self, utc_time, lon, lat):\n pass\n\n def find_aol(self, utc_time, lon, lat):\n pass\n\n def get_observer_look(self, utc_time, lon, lat, alt):\n \"\"\"Calculate observers look angle to a satellite.\n http://celestrak.com/columns/v02n02/\n\n utc_time: Observation time (datetime object)\n lon: Longitude of observer position on ground in degrees east\n lat: Latitude of observer position on ground in degrees north\n alt: Altitude above sea-level (geoid) of observer position on ground in km\n\n Return: (Azimuth, Elevation)\n \"\"\"\n\n utc_time = dt2np(utc_time)\n (pos_x, pos_y, pos_z), (vel_x, vel_y, vel_z) = self.get_position(\n utc_time, normalize=False)\n (opos_x, opos_y, opos_z), (ovel_x, ovel_y, ovel_z) = \\\n astronomy.observer_position(utc_time, lon, lat, alt)\n\n lon = np.deg2rad(lon)\n lat = np.deg2rad(lat)\n\n theta = (astronomy.gmst(utc_time) + lon) % (2 * np.pi)\n\n rx = pos_x - opos_x\n ry = pos_y - opos_y\n rz = pos_z - opos_z\n\n sin_lat = np.sin(lat)\n cos_lat = np.cos(lat)\n sin_theta = np.sin(theta)\n cos_theta = np.cos(theta)\n\n top_s = sin_lat * cos_theta * rx + \\\n sin_lat * sin_theta * ry - cos_lat * rz\n top_e = -sin_theta * rx + cos_theta * ry\n top_z = cos_lat * cos_theta * rx + \\\n cos_lat * sin_theta * ry + sin_lat * rz\n\n az_ = np.arctan(-top_e / top_s)\n\n az_ = np.where(top_s > 0, az_ + np.pi, az_)\n az_ = np.where(az_ < 0, az_ + 2 * np.pi, az_)\n\n rg_ = np.sqrt(rx * rx + ry * ry + rz * rz)\n el_ = np.arcsin(top_z / rg_)\n\n return np.rad2deg(az_), np.rad2deg(el_)\n\n def get_orbit_number(self, utc_time, tbus_style=False, as_float=False):\n \"\"\"Calculate orbit number at specified time.\n\n Args:\n tbus_style: If True, use TBUS-style orbit numbering (TLE orbit number + 1)\n as_float: Return a continuous orbit number as float.\n \"\"\"\n utc_time = np.datetime64(utc_time)\n try:\n dt = astronomy._days(utc_time - self.orbit_elements.an_time)\n orbit_period = astronomy._days(self.orbit_elements.an_period)\n except AttributeError:\n pos_epoch, vel_epoch = self.get_position(self.tle.epoch,\n normalize=False)\n if np.abs(pos_epoch[2]) > 1 or not vel_epoch[2] > 0:\n # Epoch not at ascending node\n self.orbit_elements.an_time = self.get_last_an_time(\n self.tle.epoch)\n else:\n # Epoch at ascending node (z < 1 km) and positive v_z\n self.orbit_elements.an_time = self.tle.epoch\n\n self.orbit_elements.an_period = self.orbit_elements.an_time - \\\n self.get_last_an_time(self.orbit_elements.an_time\n - np.timedelta64(10, 'm'))\n\n dt = astronomy._days(utc_time - self.orbit_elements.an_time)\n orbit_period = astronomy._days(self.orbit_elements.an_period)\n\n orbit = self.tle.orbit + dt / orbit_period + \\\n self.tle.mean_motion_derivative * dt ** 2 + \\\n self.tle.mean_motion_sec_derivative * dt ** 3\n if not as_float:\n orbit = int(orbit)\n\n if tbus_style:\n orbit += 1\n\n return orbit\n\n def get_next_passes(self, utc_time, length, lon, lat, alt, tol=0.001, horizon=0):\n \"\"\"Calculate passes for the next hours for a given start time and a\n given observer.\n\n Original by Martin.\n\n :utc_time: Observation time (datetime object)\n :length: Number of hours to find passes (int)\n :lon: Longitude of observer position on ground (float)\n :lat: Latitude of observer position on ground (float)\n :alt: Altitude above sea-level (geoid) of observer position on ground (float)\n :tol: precision of the result in seconds\n :horizon: the elevation of horizon to compute risetime and falltime.\n\n :return: [(rise-time, fall-time, max-elevation-time), ...]\n \"\"\"\n\n def elevation(minutes):\n \"\"\"Compute the elevation.\"\"\"\n return self.get_observer_look(utc_time +\n timedelta(\n minutes=np.float64(minutes)),\n lon, lat, alt)[1] - horizon\n\n def elevation_inv(minutes):\n \"\"\"Compute the inverse of elevation.\"\"\"\n return -elevation(minutes)\n\n def get_root(fun, start, end, tol=0.01):\n \"\"\"Root finding scheme\"\"\"\n x_0 = end\n x_1 = start\n fx_0 = fun(end)\n fx_1 = fun(start)\n if abs(fx_0) < abs(fx_1):\n fx_0, fx_1 = fx_1, fx_0\n x_0, x_1 = x_1, x_0\n\n x_n = optimize.brentq(fun, x_0, x_1)\n return x_n\n\n def get_max_parab(fun, start, end, tol=0.01):\n \"\"\"Successive parabolic interpolation.\"\"\"\n a = float(start)\n c = float(end)\n b = (a + c) / 2.0\n\n f_a = fun(a)\n f_b = fun(b)\n f_c = fun(c)\n\n x = b\n with np.errstate(invalid='raise'):\n while True:\n try:\n x = x - 0.5 * (((b - a) ** 2 * (f_b - f_c)\n - (b - c) ** 2 * (f_b - f_a)) /\n ((b - a) * (f_b - f_c) - (b - c) * (f_b - f_a)))\n except FloatingPointError:\n return b\n if abs(b - x) <= tol:\n return x\n\n a, b, c = (a + x) / 2.0, x, (x + c) / 2.0\n f_a, f_b, f_c = fun(a), fun(b), fun(c)\n\n # every minute\n times = utc_time + np.array([timedelta(minutes=minutes)\n for minutes in range(length * 60)])\n elev = self.get_observer_look(times, lon, lat, alt)[1] - horizon\n zcs = np.where(np.diff(np.sign(elev)))[0]\n res = []\n risetime = None\n falltime = None\n for guess in zcs:\n horizon_mins = get_root(\n elevation, guess, guess + 1.0, tol=tol / 60.0)\n horizon_time = utc_time + timedelta(minutes=horizon_mins)\n if elev[guess] < 0:\n risetime = horizon_time\n risemins = horizon_mins\n falltime = None\n else:\n falltime = horizon_time\n fallmins = horizon_mins\n if risetime:\n int_start = max(0, int(np.floor(risemins)))\n int_end = min(len(elev), int(np.ceil(fallmins) + 1))\n middle = int_start + np.argmax(elev[int_start:int_end])\n highest = utc_time + \\\n timedelta(minutes=get_max_parab(\n elevation_inv,\n max(risemins, middle - 1), min(fallmins, middle + 1),\n tol=tol / 60.0\n ))\n res += [(risetime, falltime, highest)]\n risetime = None\n return res\n\n def _get_time_at_horizon(self, utc_time, obslon, obslat, **kwargs):\n \"\"\"Get the time closest in time to *utc_time* when the\n satellite is at the horizon relative to the position of an observer on\n ground (altitude = 0)\n\n Note: This is considered deprecated and it's functionality is currently\n replaced by 'get_next_passes'.\n \"\"\"\n warnings.warn(\"_get_time_at_horizon is replaced with get_next_passes\",\n DeprecationWarning)\n if \"precision\" in kwargs:\n precision = kwargs['precision']\n else:\n precision = timedelta(seconds=0.001)\n if \"max_iterations\" in kwargs:\n nmax_iter = kwargs[\"max_iterations\"]\n else:\n nmax_iter = 100\n\n sec_step = 0.5\n t_step = timedelta(seconds=sec_step / 2.0)\n\n # Local derivative:\n def fprime(timex):\n el0 = self.get_observer_look(timex - t_step,\n obslon, obslat, 0.0)[1]\n el1 = self.get_observer_look(timex + t_step,\n obslon, obslat, 0.0)[1]\n return el0, (abs(el1) - abs(el0)) / sec_step\n\n tx0 = utc_time - timedelta(seconds=1.0)\n tx1 = utc_time\n idx = 0\n # eps = 500.\n eps = 100.\n while abs(tx1 - tx0) > precision and idx < nmax_iter:\n tx0 = tx1\n fpr = fprime(tx0)\n # When the elevation is high the scale is high, and when\n # the elevation is low the scale is low\n # var_scale = np.abs(np.sin(fpr[0] * np.pi/180.))\n # var_scale = np.sqrt(var_scale)\n var_scale = np.abs(fpr[0])\n tx1 = tx0 - timedelta(seconds=(eps * var_scale * fpr[1]))\n idx = idx + 1\n # print idx, tx0, tx1, var_scale, fpr\n if abs(tx1 - utc_time) < precision and idx < 2:\n tx1 = tx1 + timedelta(seconds=1.0)\n\n if abs(tx1 - tx0) <= precision and idx < nmax_iter:\n return tx1\n else:\n return None\n\n def utc2local(self, utc_time):\n \"\"\"Convert UTC to local time.\"\"\"\n lon, _, _ = self.get_lonlatalt(utc_time)\n return utc_time + timedelta(hours=lon * 24 / 360.0)\n\n def get_equatorial_crossing_time(self, tstart, tend, node='ascending', local_time=False,\n rtol=1E-9):\n \"\"\"Estimate the equatorial crossing time of an orbit.\n\n The crossing time is determined via the orbit number, which increases by one if the\n spacecraft passes the ascending node at the equator. A bisection algorithm is used to find\n the time of that passage.\n\n Args:\n tstart: Start time of the orbit\n tend: End time of the orbit. Orbit number at the end must be at least one greater than\n at the start. If there are multiple revolutions in the given time interval, the\n crossing time of the last revolution in that interval will be computed.\n node: Specifies whether to compute the crossing time at the ascending or descending\n node. Choices: ('ascending', 'descending').\n local_time: By default the UTC crossing time is returned. Use this flag to convert UTC\n to local time.\n rtol: Tolerance of the bisection algorithm. The smaller the tolerance, the more accurate\n the result.\n \"\"\"\n # Determine orbit number at the start and end of the orbit.\n n_start = self.get_orbit_number(tstart, as_float=True)\n n_end = self.get_orbit_number(tend, as_float=True)\n if int(n_end) - int(n_start) == 0:\n # Orbit doesn't cross the equator in the given time interval\n return None\n elif n_end - n_start > 1:\n warnings.warn('Multiple revolutions between start and end time. Computing crossing '\n 'time for the last revolution in that interval.')\n\n # Let n'(t) = n(t) - offset. Determine offset so that n'(tstart) < 0 and n'(tend) > 0 and\n # n'(tcross) = 0.\n offset = int(n_end)\n if node == 'descending':\n offset = offset + 0.5\n\n # Use bisection algorithm to find the root of n'(t), which is the crossing time. The\n # algorithm requires continuous time coordinates, so convert timestamps to microseconds\n # since 1970.\n time_unit = 'us' # same precision as datetime\n\n def _nprime(time_f):\n \"\"\"Continuous orbit number as a function of time.\"\"\"\n time64 = np.datetime64(int(time_f), time_unit)\n n = self.get_orbit_number(time64, as_float=True)\n return n - offset\n\n try:\n tcross = optimize.bisect(_nprime,\n a=np.datetime64(tstart, time_unit).astype(np.int64),\n b=np.datetime64(tend, time_unit).astype(np.int64),\n rtol=rtol)\n except ValueError:\n # Bisection did not converge\n return None\n tcross = np.datetime64(int(tcross), time_unit).astype(datetime)\n\n # Convert UTC to local time\n if local_time:\n tcross = self.utc2local(tcross)\n\n return tcross\n\n\nclass OrbitElements(object):\n\n \"\"\"Class holding the orbital elements.\n \"\"\"\n\n def __init__(self, tle):\n self.epoch = tle.epoch\n self.excentricity = tle.excentricity\n self.inclination = np.deg2rad(tle.inclination)\n self.right_ascension = np.deg2rad(tle.right_ascension)\n self.arg_perigee = np.deg2rad(tle.arg_perigee)\n self.mean_anomaly = np.deg2rad(tle.mean_anomaly)\n\n self.mean_motion = tle.mean_motion * (np.pi * 2 / XMNPDA)\n self.mean_motion_derivative = tle.mean_motion_derivative * \\\n np.pi * 2 / XMNPDA ** 2\n self.mean_motion_sec_derivative = tle.mean_motion_sec_derivative * \\\n np.pi * 2 / XMNPDA ** 3\n self.bstar = tle.bstar * AE\n\n n_0 = self.mean_motion\n k_e = XKE\n k_2 = CK2\n i_0 = self.inclination\n e_0 = self.excentricity\n\n a_1 = (k_e / n_0) ** (2.0 / 3)\n delta_1 = ((3 / 2.0) * (k_2 / a_1**2) * ((3 * np.cos(i_0)**2 - 1) /\n (1 - e_0**2)**(2.0 / 3)))\n\n a_0 = a_1 * (1 - delta_1 / 3 - delta_1**2 - (134.0 / 81) * delta_1**3)\n\n delta_0 = ((3 / 2.0) * (k_2 / a_0**2) * ((3 * np.cos(i_0)**2 - 1) /\n (1 - e_0**2)**(2.0 / 3)))\n\n # original mean motion\n n_0pp = n_0 / (1 + delta_0)\n self.original_mean_motion = n_0pp\n\n # semi major axis\n a_0pp = a_0 / (1 - delta_0)\n self.semi_major_axis = a_0pp\n\n self.period = np.pi * 2 / n_0pp\n\n self.perigee = (a_0pp * (1 - e_0) / AE - AE) * XKMPER\n\n self.right_ascension_lon = (self.right_ascension\n - astronomy.gmst(self.epoch))\n\n if self.right_ascension_lon > np.pi:\n self.right_ascension_lon -= 2 * np.pi\n\n\nclass _SGDP4(object):\n\n \"\"\"Class for the SGDP4 computations.\n \"\"\"\n\n def __init__(self, orbit_elements):\n self.mode = None\n\n # perigee = orbit_elements.perigee\n self.eo = orbit_elements.excentricity\n self.xincl = orbit_elements.inclination\n self.xno = orbit_elements.original_mean_motion\n # k_2 = CK2\n # k_4 = CK4\n # k_e = XKE\n self.bstar = orbit_elements.bstar\n self.omegao = orbit_elements.arg_perigee\n self.xmo = orbit_elements.mean_anomaly\n self.xnodeo = orbit_elements.right_ascension\n self.t_0 = orbit_elements.epoch\n self.xn_0 = orbit_elements.mean_motion\n # A30 = -XJ3 * AE**3\n\n if not(0 < self.eo < ECC_LIMIT_HIGH):\n raise OrbitalError('Eccentricity out of range: %e' % self.eo)\n elif not((0.0035 * 2 * np.pi / XMNPDA) < self.xn_0 < (18 * 2 * np.pi / XMNPDA)):\n raise OrbitalError('Mean motion out of range: %e' % self.xn_0)\n elif not(0 < self.xincl < np.pi):\n raise OrbitalError('Inclination out of range: %e' % self.xincl)\n\n if self.eo < 0:\n self.mode = self.SGDP4_ZERO_ECC\n return\n\n self.cosIO = np.cos(self.xincl)\n self.sinIO = np.sin(self.xincl)\n theta2 = self.cosIO**2\n theta4 = theta2 ** 2\n self.x3thm1 = 3.0 * theta2 - 1.0\n self.x1mth2 = 1.0 - theta2\n self.x7thm1 = 7.0 * theta2 - 1.0\n\n a1 = (XKE / self.xn_0) ** (2. / 3)\n betao2 = 1.0 - self.eo**2\n betao = np.sqrt(betao2)\n temp0 = 1.5 * CK2 * self.x3thm1 / (betao * betao2)\n del1 = temp0 / (a1**2)\n a0 = a1 * \\\n (1.0 - del1 * (1.0 / 3.0 + del1 * (1.0 + del1 * 134.0 / 81.0)))\n del0 = temp0 / (a0**2)\n self.xnodp = self.xn_0 / (1.0 + del0)\n self.aodp = (a0 / (1.0 - del0))\n self.perigee = (self.aodp * (1.0 - self.eo) - AE) * XKMPER\n self.apogee = (self.aodp * (1.0 + self.eo) - AE) * XKMPER\n self.period = (2 * np.pi * 1440.0 / XMNPDA) / self.xnodp\n\n if self.period >= 225:\n # Deep-Space model\n self.mode = SGDP4_DEEP_NORM\n elif self.perigee < 220:\n # Near-space, simplified equations\n self.mode = SGDP4_NEAR_SIMP\n else:\n # Near-space, normal equations\n self.mode = SGDP4_NEAR_NORM\n\n if self.perigee < 156:\n s4 = self.perigee - 78\n if s4 < 20:\n s4 = 20\n\n qoms24 = ((120 - s4) * (AE / XKMPER))**4\n s4 = (s4 / XKMPER + AE)\n else:\n s4 = KS\n qoms24 = QOMS2T\n\n pinvsq = 1.0 / (self.aodp**2 * betao2**2)\n tsi = 1.0 / (self.aodp - s4)\n self.eta = self.aodp * self.eo * tsi\n etasq = self.eta**2\n eeta = self.eo * self.eta\n psisq = np.abs(1.0 - etasq)\n coef = qoms24 * tsi**4\n coef_1 = coef / psisq**3.5\n\n self.c2 = (coef_1 * self.xnodp * (self.aodp *\n (1.0 + 1.5 * etasq + eeta * (4.0 + etasq)) +\n (0.75 * CK2) * tsi / psisq * self.x3thm1 *\n (8.0 + 3.0 * etasq * (8.0 + etasq))))\n\n self.c1 = self.bstar * self.c2\n\n self.c4 = (2.0 * self.xnodp * coef_1 * self.aodp * betao2 * (\n self.eta * (2.0 + 0.5 * etasq) + self.eo * (0.5 + 2.0 * etasq) - (2.0 * CK2) * tsi /\n (self.aodp * psisq) * (-3.0 * self.x3thm1 * (1.0 - 2.0 * eeta + etasq * (1.5 - 0.5 * eeta)) +\n 0.75 * self.x1mth2 * (2.0 * etasq - eeta * (1.0 + etasq)) *\n np.cos(2.0 * self.omegao))))\n\n self.c5, self.c3, self.omgcof = 0.0, 0.0, 0.0\n\n if self.mode == SGDP4_NEAR_NORM:\n self.c5 = (2.0 * coef_1 * self.aodp * betao2 *\n (1.0 + 2.75 * (etasq + eeta) + eeta * etasq))\n if self.eo > ECC_ALL:\n self.c3 = coef * tsi * A3OVK2 * \\\n self.xnodp * AE * self.sinIO / self.eo\n self.omgcof = self.bstar * self.c3 * np.cos(self.omegao)\n\n temp1 = 3.0 * CK2 * pinvsq * self.xnodp\n temp2 = temp1 * CK2 * pinvsq\n temp3 = 1.25 * CK4 * pinvsq**2 * self.xnodp\n\n self.xmdot = (self.xnodp + (0.5 * temp1 * betao * self.x3thm1 + 0.0625 *\n temp2 * betao * (13.0 - 78.0 * theta2 +\n 137.0 * theta4)))\n\n x1m5th = 1.0 - 5.0 * theta2\n\n self.omgdot = (-0.5 * temp1 * x1m5th + 0.0625 * temp2 *\n (7.0 - 114.0 * theta2 + 395.0 * theta4) +\n temp3 * (3.0 - 36.0 * theta2 + 49.0 * theta4))\n\n xhdot1 = -temp1 * self.cosIO\n self.xnodot = (xhdot1 + (0.5 * temp2 * (4.0 - 19.0 * theta2) +\n 2.0 * temp3 * (3.0 - 7.0 * theta2)) * self.cosIO)\n\n if self.eo > ECC_ALL:\n self.xmcof = (-(2. / 3) * AE) * coef * self.bstar / eeta\n else:\n self.xmcof = 0.0\n\n self.xnodcf = 3.5 * betao2 * xhdot1 * self.c1\n self.t2cof = 1.5 * self.c1\n\n # Check for possible divide-by-zero for X/(1+cos(xincl)) when\n # calculating xlcof */\n temp0 = 1.0 + self.cosIO\n if np.abs(temp0) < EPS_COS:\n temp0 = np.sign(temp0) * EPS_COS\n\n self.xlcof = 0.125 * A3OVK2 * self.sinIO * \\\n (3.0 + 5.0 * self.cosIO) / temp0\n\n self.aycof = 0.25 * A3OVK2 * self.sinIO\n\n self.cosXMO = np.cos(self.xmo)\n self.sinXMO = np.sin(self.xmo)\n self.delmo = (1.0 + self.eta * self.cosXMO)**3\n\n if self.mode == SGDP4_NEAR_NORM:\n c1sq = self.c1**2\n self.d2 = 4.0 * self.aodp * tsi * c1sq\n temp0 = self.d2 * tsi * self.c1 / 3.0\n self.d3 = (17.0 * self.aodp + s4) * temp0\n self.d4 = 0.5 * temp0 * self.aodp * tsi * \\\n (221.0 * self.aodp + 31.0 * s4) * self.c1\n self.t3cof = self.d2 + 2.0 * c1sq\n self.t4cof = 0.25 * \\\n (3.0 * self.d3 + self.c1 * (12.0 * self.d2 + 10.0 * c1sq))\n self.t5cof = (0.2 * (3.0 * self.d4 + 12.0 * self.c1 * self.d3 + 6.0 * self.d2**2 +\n 15.0 * c1sq * (2.0 * self.d2 + c1sq)))\n\n elif self.mode == SGDP4_DEEP_NORM:\n raise NotImplementedError('Deep space calculations not supported')\n\n def propagate(self, utc_time):\n kep = {}\n\n # get the time delta in minutes\n # ts = astronomy._days(utc_time - self.t_0) * XMNPDA\n # print utc_time.shape\n # print self.t_0\n utc_time = dt2np(utc_time)\n ts = (utc_time - self.t_0) / np.timedelta64(1, 'm')\n\n em = self.eo\n xinc = self.xincl\n\n xmp = self.xmo + self.xmdot * ts\n xnode = self.xnodeo + ts * (self.xnodot + ts * self.xnodcf)\n omega = self.omegao + self.omgdot * ts\n\n if self.mode == SGDP4_ZERO_ECC:\n raise NotImplementedError('Mode SGDP4_ZERO_ECC not implemented')\n elif self.mode == SGDP4_NEAR_SIMP:\n raise NotImplementedError('Mode \"Near-space, simplified equations\"'\n ' not implemented')\n elif self.mode == SGDP4_NEAR_NORM:\n delm = self.xmcof * \\\n ((1.0 + self.eta * np.cos(xmp))**3 - self.delmo)\n temp0 = ts * self.omgcof + delm\n xmp += temp0\n omega -= temp0\n tempa = 1.0 - \\\n (ts *\n (self.c1 + ts * (self.d2 + ts * (self.d3 + ts * self.d4))))\n tempe = self.bstar * \\\n (self.c4 * ts + self.c5 * (np.sin(xmp) - self.sinXMO))\n templ = ts * ts * \\\n (self.t2cof + ts *\n (self.t3cof + ts * (self.t4cof + ts * self.t5cof)))\n a = self.aodp * tempa**2\n e = em - tempe\n xl = xmp + omega + xnode + self.xnodp * templ\n\n else:\n raise NotImplementedError('Deep space calculations not supported')\n\n if np.any(a < 1):\n raise Exception('Satellite crashed at time %s', utc_time)\n elif np.any(e < ECC_LIMIT_LOW):\n raise ValueError('Satellite modified eccentricity too low: %s < %e'\n % (str(e[e < ECC_LIMIT_LOW]), ECC_LIMIT_LOW))\n\n e = np.where(e < ECC_EPS, ECC_EPS, e)\n e = np.where(e > ECC_LIMIT_HIGH, ECC_LIMIT_HIGH, e)\n\n beta2 = 1.0 - e**2\n\n # Long period periodics\n sinOMG = np.sin(omega)\n cosOMG = np.cos(omega)\n\n temp0 = 1.0 / (a * beta2)\n axn = e * cosOMG\n ayn = e * sinOMG + temp0 * self.aycof\n xlt = xl + temp0 * self.xlcof * axn\n\n elsq = axn**2 + ayn**2\n\n if np.any(elsq >= 1):\n raise Exception('e**2 >= 1 at %s', utc_time)\n\n kep['ecc'] = np.sqrt(elsq)\n\n epw = np.fmod(xlt - xnode, 2 * np.pi)\n # needs a copy in case of an array\n capu = np.array(epw)\n maxnr = kep['ecc']\n for i in range(10):\n sinEPW = np.sin(epw)\n cosEPW = np.cos(epw)\n\n ecosE = axn * cosEPW + ayn * sinEPW\n esinE = axn * sinEPW - ayn * cosEPW\n f = capu - epw + esinE\n if np.all(np.abs(f) < NR_EPS):\n break\n\n df = 1.0 - ecosE\n\n # 1st order Newton-Raphson correction.\n nr = f / df\n\n # 2nd order Newton-Raphson correction.\n nr = np.where(np.logical_and(i == 0, np.abs(nr) > 1.25 * maxnr),\n np.sign(nr) * maxnr,\n f / (df + 0.5 * esinE * nr))\n epw += nr\n\n # Short period preliminary quantities\n temp0 = 1.0 - elsq\n betal = np.sqrt(temp0)\n pl = a * temp0\n r = a * (1.0 - ecosE)\n invR = 1.0 / r\n temp2 = a * invR\n temp3 = 1.0 / (1.0 + betal)\n cosu = temp2 * (cosEPW - axn + ayn * esinE * temp3)\n sinu = temp2 * (sinEPW - ayn - axn * esinE * temp3)\n u = np.arctan2(sinu, cosu)\n sin2u = 2.0 * sinu * cosu\n cos2u = 2.0 * cosu**2 - 1.0\n temp0 = 1.0 / pl\n temp1 = CK2 * temp0\n temp2 = temp1 * temp0\n\n # Update for short term periodics to position terms.\n\n rk = r * (1.0 - 1.5 * temp2 * betal * self.x3thm1) + \\\n 0.5 * temp1 * self.x1mth2 * cos2u\n uk = u - 0.25 * temp2 * self.x7thm1 * sin2u\n xnodek = xnode + 1.5 * temp2 * self.cosIO * sin2u\n xinck = xinc + 1.5 * temp2 * self.cosIO * self.sinIO * cos2u\n\n if np.any(rk < 1):\n raise Exception('Satellite crashed at time %s', utc_time)\n\n temp0 = np.sqrt(a)\n temp2 = XKE / (a * temp0)\n rdotk = ((XKE * temp0 * esinE * invR - temp2 * temp1 * self.x1mth2 * sin2u) *\n (XKMPER / AE * XMNPDA / 86400.0))\n rfdotk = ((XKE * np.sqrt(pl) * invR + temp2 * temp1 *\n (self.x1mth2 * cos2u + 1.5 * self.x3thm1)) *\n (XKMPER / AE * XMNPDA / 86400.0))\n\n kep['radius'] = rk * XKMPER / AE\n kep['theta'] = uk\n kep['eqinc'] = xinck\n kep['ascn'] = xnodek\n kep['argp'] = omega\n kep['smjaxs'] = a * XKMPER / AE\n kep['rdotk'] = rdotk\n kep['rfdotk'] = rfdotk\n\n return kep\n\n\ndef kep2xyz(kep):\n sinT = np.sin(kep['theta'])\n cosT = np.cos(kep['theta'])\n sinI = np.sin(kep['eqinc'])\n cosI = np.cos(kep['eqinc'])\n sinS = np.sin(kep['ascn'])\n cosS = np.cos(kep['ascn'])\n\n xmx = -sinS * cosI\n xmy = cosS * cosI\n\n ux = xmx * sinT + cosS * cosT\n uy = xmy * sinT + sinS * cosT\n uz = sinI * sinT\n\n x = kep['radius'] * ux\n y = kep['radius'] * uy\n z = kep['radius'] * uz\n\n vx = xmx * cosT - cosS * sinT\n vy = xmy * cosT - sinS * sinT\n vz = sinI * cosT\n\n v_x = kep['rdotk'] * ux + kep['rfdotk'] * vx\n v_y = kep['rdotk'] * uy + kep['rfdotk'] * vy\n v_z = kep['rdotk'] * uz + kep['rfdotk'] * vz\n\n return np.array((x, y, z)), np.array((v_x, v_y, v_z))\n\n\nif __name__ == \"__main__\":\n obs_lon, obs_lat = np.deg2rad((12.4143, 55.9065))\n obs_alt = 0.02\n o = Orbital(satellite=\"METOP-B\")\n\n t_start = datetime.now()\n t_stop = t_start + timedelta(minutes=20)\n t = t_start\n while t < t_stop:\n t += timedelta(seconds=15)\n lon, lat, alt = o.get_lonlatalt(t)\n lon, lat = np.rad2deg((lon, lat))\n az, el = o.get_observer_look(t, obs_lon, obs_lat, obs_alt)\n ob = o.get_orbit_number(t, tbus_style=True)\n print(az, el, ob)\n",
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Fri Jan 25 15:46:56 2013\n\n@author: miguelnunes\n\nnotes on the attitude code\n- for books and papers the quaternion representation with scalar last is common\n but for programming it's more common to find scalar first representation\n- to avoid confusion I use: \n q = [q1,q2,q3, q4] for scalar last (q4) \n and \n q = [q0, q1,q2,q4] for scalar first (q0) \n \n notice that q1,q2,q3 are the vector components for both cases\n \n references:\n [1] - Analytical Mechanics of Space Systems, Shaub & Junkins, 2003\n\n\"\"\"\n\nimport numpy as np\nfrom numpy.linalg import inv\nfrom scipy import integrate\n#import matplotlib.pyplot as plt\n#from matplotlib import plot, ion, show\nfrom matplotlib.pylab import *\n#import transformations as tr\n#from transformations import *\n\n#########################################\n# FUNCTIONS\n#########################################\n#def skew(x):\n# # quaternion representation, scalar last, q=(q1,q2,q3,q4_scalar)\n# return array( [ ( 0 , -x[2], x[1]), \n# ( x[2], 0, -x[0]),\n# (-x[1], x[0], 0 ) ] )\n\ndef skew(x):\n # quaternion representation, scalar first, q=(q0,q1,q2,q3)\n # MUST CHECK!!! now it's probvably the same as scalar last!\n return np.array( [ ( 0 , -x[2], x[1]), \n ( x[2], 0, -x[0]),\n (-x[1], x[0], 0 ) ] )\n#def skew4(x):\n# # quaternion representation, scalar last, q=(q1,q2,q3,q4_scalar)\n# # eqn 2.1.7, pg 8\n# return array( [ ( 0 , x[2], -x[1], x[0]), \n# ( -x[2], 0 , x[0], x[1]),\n# ( x[1], -x[0], 0 , x[2]),\n# ( -x[0], -x[1], -x[2], 0) ] )\n\ndef skew4(x):\n # quaternion representation, scalar first, q=(q0,q1,q2,q3)\n # reference [1.100]\n w1 = x[0]\n w2 = x[1]\n w3 = x[2]\n return np.array( [ [ 0, -w1, -w2, -w3], \n [ w1, 0 , w3, -w2],\n [ w2, -w3, 0 , w1],\n [ w3, w2, -w1, 0 ] ] )\n\n#def euler2quaternion_test(euler):\n# # from http://www.gamedev.net/topic/597324-quaternion-to-euler-angles-and-back-why-is-the-rotation-changing/\n# eX,eY,eZ = euler[0],euler[1],euler[2]\n# \n# c1 = cos(eX/2);\n# s1 = sin(eX/2);\n# \n# c2 = cos(eY/2);\n# s2 = sin(eY/2);\n# \n# c3 = cos(eZ/2);\n# s3 = sin(eZ/2);\n# \n# qx = s1*c2*c3 + c1*s2*s3;\n# qy = c1*s2*c3 - s1*c2*s3;\n# qz = c1*c2*s3 + s1*s2*c3; \n# \n# qw = c1*c2*c3 - s1*s2*s3;\n# \n# return array([qx,qy,qz,qw])\n \ndef quaternion_from_euler(euler):\n \"\"\"\n Convert euler angles to a quaternion with scalar first representation\n \"\"\"\n # aerospace standard Euler angles sequence Z,Y,X = yaw, pitch, roll\n # 1, psi - z (yaw,heading)\n # 2, theta - y (pitch)\n # 3, phi - x (roll)\n \n # check if pitch is not in [-90, 90] deg domain\n if euler[1] >= pi/2:\n print(\">>> WARNING! Pitch is more than 90 deg. Results may not be accurate\")\n \n if euler[1] <= -pi/2:\n print(\">>> WARNING! Pitch is less than -90 deg. Results may not be accurate\")\n \n \n #angles = array([r, p, y])\n c = np.cos( euler/2. )\n s = np.sin( euler/2. )\n \n # formulat from Space Vehicle Dynamics and Control, Wie, pg 338\n # q1,q2,q3,q4/scalar\n #q = [s(:,1).*c(:,2).*c(:,3) - c(:,1).*s(:,2).*s(:,3), ...\n # c(:,1).*s(:,2).*c(:,3) + s(:,1).*c(:,2).*s(:,3), ...\n # c(:,1).*c(:,2).*s(:,3) - s(:,1).*s(:,2).*c(:,3), ...\n # c(:,1).*c(:,2).*c(:,3) + s(:,1).*s(:,2).*s(:,3)];\n \n # eqn A.2.15\n# q1 = s[0]*c[1]*c[2] - c[0]*s[1]*s[2]\n# q2 = c[0]*s[1]*c[2] + s[0]*c[1]*s[2]\n# q3 = c[0]*c[1]*s[2] - s[0]*s[1]*c[2]\n# q4 = c[0]*c[1]*c[2] + s[0]*s[1]*s[2]\n\n # from book: Quaternions and Rotation Sequences pg 167 \n # scalar first representation \n q0 = c[0]*c[1]*c[2] + s[0]*s[1]*s[2]\n q1 = c[0]*c[1]*s[2] - s[0]*s[1]*c[2]\n q2 = c[0]*s[1]*c[2] + s[0]*c[1]*s[2]\n q3 = s[0]*c[1]*c[2] - c[0]*s[1]*s[2]\n\n #scalar first\n return np.array([ q0, q1, q2, q3])\n\n\n# before quaternion2euler_aero\ndef euler_from_quaternion(q):\n # from book: Quaternions and Rotation Sequences pg 168\n # assumes q = [q0, q1, q2, q3] (scalar first)\n\n dcm = dcm_from_quaternion(q)\n \n psi = np.arctan2(dcm[0,1],dcm[0,0]) #yaw\n theta = np.arcsin(-dcm[0,2]) #pitch \n phi = np.arctan2(dcm[1,2],dcm[2,2]) #roll \n \n return np.array([psi,theta,phi])\n \n\ndef euler_from_quaternion_scalar_last(q):\n # ref: https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles\n # assumes q = [q1, q2, q3, q4] (scalar last)\n\n q1,q2,q3,q4 = q \n \n phi = np.arctan2( 2*(q4*q1 + q2*q3), 1-2*(q1*q1 + q2*q2) ) #yaw\n theta = np.arcsin( 2*(q4*q2 - q3*q1) ) #pitch \n psi = np.arctan2( 2*(q4*q3 + q1*q2), 1-2*(q2*q2 + q3*q3)) #roll \n \n return np.array([psi,theta,phi])\n\n#def quaternion2euler_test(q):\n# # from http://www.gamedev.net/topic/597324-quaternion-to-euler-angles-and-back-why-is-the-rotation-changing/\n# \n# qx,qy,qz,qw = q[0],q[1],q[2],q[3]\n# \n# eX = arctan2(-2*(qy*qz-qw*qx), qw*qw-qx*qx-qy*qy+qz*qz)\n# eY = arcsin(2*(qx*qz + qw*qy))\n# eZ = arctan2(-2*(qx*qy-qw*qz), qw*qw+qx*qx-qy*qy-qz*qz)\n# \n# return array([eX,eY,eZ])\n \ndef quatNorm(q):\n '''\n normalize quaternion\n '''\n return q/np.sqrt(np.dot(q,q))\n \n# ------------------------------------------------------------------------------\n# DCM operations\n\ndef dcm_from_euler(euler):\n # from book: Quaternions and Rotation Sequences pg 167\n \n psi, theta, phi = euler\n \n cpsi = np.cos(psi)\n spsi = np.sin(psi)\n \n ctheta = np.cos(theta)\n stheta = np.sin(theta)\n \n cphi = np.cos(phi) \n sphi = np.sin(phi)\n \n return np.array([\n [cpsi*ctheta , spsi*ctheta , -stheta ],\n [cpsi*stheta*sphi - spsi*cphi , spsi*stheta*sphi + cpsi*cphi , ctheta*sphi],\n [cpsi*stheta*cphi + spsi*sphi , spsi*stheta*cphi - cpsi*sphi , ctheta*cphi]\n ])\n \n\n#def dcm_from_quaternion(q):\n# #eqn A.2.13\n# # from Wertz pg 414\n# # q = [q1,q2,q3,q4_scalar)]\n# q1,q2,q3,q4 = q[0],q[1],q[2],q[3]\n# \n# return array([\n# [q1**2 - q2**2 -q3**2 + q4**2, 2*(q1*q2-q3*q4), 2*(q1*q3+q2*q4)],\n# [2*(q1*q2+q3*q4), -q1**2 + q2**2 - q3**2 + q4**2, 2*(q2*q3-q1*q4)],\n# [2*(q1*q3-q2*q4), 2*(q2*q3+q1*q4), -q1**2 - q2**2 + q3**2 + q4**2]\n# ])\n\n# before: quaternion2dcm_aero \ndef dcm_from_quaternion(q):\n # from book: Quaternions and Rotation Sequences pg 168\n q0,q1,q2,q3 = q #[0],q[1],q[2],q[3]\n \n return np.array([\n [2*q0**2-1+2*q1**2, 2*(q1*q2+q0*q3), 2*(q1*q3-q0*q2)],\n [2*(q1*q2-q0*q3), 2*q0**2-1+2*q2**2, 2*(q2*q3+q0*q1)],\n [2*(q1*q3+q0*q2), 2*(q2*q3-q0*q1), 2*q0**2-1+2*q3**2]\n ])\n\n###############################################################################\n# Rotations\n\n# difference between passive and active transformation\n# passive transformation - rotates the frame, but the point/vector remains fixed\n# active transformation - rotates the point/vector but the frame remains fixed\n# http://en.wikipedia.org/wiki/Active_and_passive_transformation\ndef rotX3d_passive(angle):\n # coordinate frame transformation (passive transformation/rotation) \n # through the given angle \n cang = np.cos(angle)\n sang = np.sin(angle)\n \n return np.array([\n [1, 0 , 0 ],\n [0, cang, sang ],\n [0 , -sang, cang ],\n ])\ndef rotY3d_passive(angle):\n # coordinate frame transformation (passive transformation/rotation) \n # through the given angle \n cang = np.cos(angle)\n sang = np.sin(angle)\n \n return np.array([\n [ cang , 0 , -sang],\n [ 0 , 1 , 0 ],\n [ sang , 0 , cang]\n ])\ndef rotZ3d_passive(angle):\n # coordinate frame transformation (passive transformation/rotation) \n # through the given angle \n cang = np.cos(angle)\n sang = np.sin(angle)\n \n return np.array([\n [ cang, sang, 0],\n [-sang, cang, 0],\n [ 0 , 0 , 1]\n ])\n\n\ndef rotX3d_active(angle):\n # point transfromation (active transformation/rotation)\n # through the given angle\n \n # it's just the inverse or transpose of the passive transformation\n return rotX3d_passive(angle).T\n\ndef rotY3d_active(angle):\n # point transfromation (active transformation/rotation)\n # through the given angle\n \n # it's just the inverse or transpose of the passive transformation\n return rotY3d_passive(angle).T\n \ndef rotZ3d_active(angle):\n # point transfromation (active transformation/rotation)\n # through the given angle\n \n # it's just the inverse or transpose of the passive transformation\n return rotZ3d_passive(angle).T\n\n\n \n#########################################\n# DYNAMICS + KINEMATICS\n#########################################\n# dynamics\n#omega = array( [1,2,3] )\n#torque = array( [0,0,0] )\n#domega = dot(inv(I), dot( dot(-skew(omega), Inertia), omega) + torque )\n\ndef attitude_dynamics(X, t, Torque, Inertia):\n #global Inertia\n \n #state vector x = (q0,q1,q2,q3, wx,wy,wz)\n q = X[0:4]\n omega_b_i = X[4:7]\n \n #print(omega_b_i)\n\n #satellite kinematics\n #omega_b_o is angular velocity of body frame wrt orbital???? or inertial .. frame \n # represented in body frame - IMU\n #omega_b_i = omega\n dq = 0.5*np.dot(skew4(omega_b_i),q)\n \n #print(dq)\n\n #satellite dynamics, pg 6\n # inv(skew_omega * Inertia) * omega + torque\n domega = np.dot(inv(Inertia), np.dot( np.dot(-skew(omega_b_i), Inertia), omega_b_i) + Torque)\n\n #print(domega)\n \n dX = np.concatenate((dq,domega),axis=None)\n #print(dX)\n \n # return state vector q, omega\n return dX\n\n#########################################\n# Linearization\n#########################################\n# linearization for quaternion scalar first formulation\ndef linearSystem_(w):\n #A = zeros([4,4])\n \n '''\n A[0,0] = 0\n A[0,1] = w[0]\n A[0,2] = w[1]\n A[0,3] = w[2]\n \n A[1,0] = w[0]\n A[1,1] = 0\n A[1,2] = w[2]\n A[1,3] = -w[1]\n \n A[2,0] = w[1]\n A[2,1] = -w[2]\n A[2,2] = 0\n A[2,3] = w[0]\n \n A[3,0] = w[2] \n A[3,1] = w[1]\n A[3,2] = -w[0]\n A[3,3] = 0\n '''\n \n A = 0.5*np.array([ ( 0 , -w[0], -w[1], -w[2] ),\n ( w[0], 0 , w[2], -w[1] ),\n ( w[1], -w[2], 0 , w[0] ),\n ( w[2], w[1], -w[0], 0 )])\n \n #A = 0.5*A\n return A\n\n\n# linearization for quaternion scalar last formulation (default!)\ndef linear_dynamics(omega,inertia):\n \n I_x = inertia[0,0]\n I_y = inertia[1,1]\n I_z = inertia[2,2]\n \n omega_x = omega[0]\n omega_y = omega[1]\n omega_z = omega[2]\n \n # attitude section\n A_q = 0.5*np.array([ ( 0 , omega_z, -omega_y, omega_x ),\n (-omega_z, 0 , omega_x, omega_y ),\n ( omega_y, -omega_x, 0 , omega_z ),\n (-omega_x, -omega_y, -omega_z, 0 )])\n \n # append the zeros matrix for the attitude part\n A_q = np.concatenate((A_q,np.zeros([4,3])),axis=1)\n\n\n # dynamics section\n \n k_1 = -(I_x - I_z)/I_y\n k_2 = (I_x - I_y)/I_z\n k_3 = (I_y - I_z)/I_x\n \n A_omega = np.array([ ( 0 , k_3*omega_z , k_3*omega_y), \n ( k_1*omega_z, 0 , k_1*omega_x), \n ( k_2*omega_y, k_2*omega_x , 0 ) ]) \n\n #print A_omega \n # append the zeros matrix for the attitude part\n A_omega = np.concatenate( (np.zeros([3,4]),A_omega), axis=1)\n \n A = np.concatenate ((A_q,A_omega), axis=0)\n #print \"#############################\"\n #print A_omega\n return A"
] |
[
[
"numpy.where",
"numpy.sign",
"numpy.cos",
"numpy.deg2rad",
"numpy.sin",
"numpy.arcsin",
"scipy.optimize.brentq",
"numpy.argmax",
"numpy.sqrt",
"numpy.array",
"numpy.float64",
"numpy.arctan",
"numpy.timedelta64",
"numpy.arctan2",
"numpy.datetime64",
"numpy.floor",
"numpy.ceil",
"numpy.errstate",
"numpy.rad2deg",
"numpy.fmod",
"numpy.any",
"numpy.abs"
],
[
"numpy.concatenate",
"numpy.array",
"numpy.sin",
"numpy.dot",
"numpy.zeros",
"numpy.arcsin",
"numpy.arctan2",
"numpy.cos",
"numpy.linalg.inv"
]
] |
mattkjames7/groundmag
|
[
"38d66aaad8ad68bae8a42805fde3e92c3180aa84"
] |
[
"groundmag/PlotPolarization.py"
] |
[
"import numpy as np\nimport matplotlib.pyplot as plt\nimport wavespec as ws\nfrom .Spectrogram3D import Spectrogram3D\nfrom .GetStationInfo import GetStationInfo\n\ndef PlotPolarization(Station,Date,wind,slip,ut=None,high=None,low=None,Freq=None,comps=['x','y'],Threshold=0.0,Method='FFT',WindowFunction=None,Param=None,Detrend=True,FindGaps=True,fig=None,maps=[1,1,0,0],TimeAxisUnits='hh:mm',nox=False,Multiplier=1.0,trange=None,useytitle=False):\n\n\t#create title string\n\tstn = GetStationInfo(Station)\n\ttitle = Station.upper()\n\tpos = '(mlat={:3.1f},mlon={:3.1f})'.format(stn.mlat[0],stn.mlon[0])\n\n\t#check if data are filtered\n\tfilt = 'Filtered: '\n\tif not low is None:\n\t\tfilt += 'low = {:3.1f} s '.format(np.float32(low))\n\tif not high is None:\n\t\tfilt += 'high = {:3.1f} s '.format(np.float32(high))\n\tif high is None and low is None:\n\t\tfilt = None\n\n\n\t#get the spectrogram\n\tNw,LenW,Freq,Spec = Spectrogram3D(Station,Date,wind,slip,ut=ut,high=high,low=low,Freq=Freq,Method=Method,WindowFunction=WindowFunction,Param=Param,Detrend=Detrend,FindGaps=FindGaps,GoodData=None)\n\t\n\t#combine the appropriate components\n\tP = Spec[comps[0]+'Pow'] + Spec[comps[1]+'Pow']\n\t\n\t#now find the most powerful peak along the time axis\n\tpk = ws.DetectWaves.DetectWavePeaks(Spec.Tspec,Freq,P,Threshold,True)\n\t\n\t#get the amplitudes and phases\n\tAx = Spec.xAmp[pk.tind,pk.find]\n\tPx = Spec.xPha[pk.tind,pk.find]\n\t\n\tAy = Spec.yAmp[pk.tind,pk.find]\n\tPy = Spec.yPha[pk.tind,pk.find]\n\t\n\tAz = Spec.zAmp[pk.tind,pk.find]\n\tPz = Spec.zPha[pk.tind,pk.find]\n\t\n\tDir = Spec.kz[pk.tind,pk.find]\n\t\n\tpol = ws.Tools.Polarization2D(Ax**2,Px,Ay**2,Py)\n\n\t#plot the polarization ellipses\n\tax = ws.Tools.PlotPolarization(pk.t,Ax,Ay,Px,Py,Dir,fig=fig,maps=maps,Multiplier=Multiplier,nox=nox,trange=None,TimeAxisUnits=TimeAxisUnits)\n\t\n\t#add the title\n\tif useytitle:\n\t\tax.set_ylabel(title)\t\n\t\tax.text(0.02,0.97,pos,transform=ax.transAxes,va='top')\n\telse:\n\t\tax.text(0.02,0.97,title+' '+pos,transform=ax.transAxes,va='top')\n\t\t\n\tif not filt is None:\n\t\tax.text(0.02,0.03,filt,transform=ax.transAxes,va='bottom')\n\t\n\t\n\treturn ax,Spec,pk,pol\n"
] |
[
[
"numpy.float32"
]
] |
futureseadev/Off-policy-off-line-ranking-evaluation
|
[
"3f67ed48a759e3ab8788c05f1c31232a4d6e2fd1"
] |
[
"src/data_synthesis.py"
] |
[
"import pandas as pd\nimport numpy as np\n\n\ndef create_context_vector():\n def parse_line_with_slash(line):\n split_line = line.split()\n return split_line[0], split_line[1].split('|')\n\n descriptionid_tokensid = []\n purchasedkeywordid_tokensid = []\n queryid_tokensid = []\n titleid_tokensid = []\n userid_profile = []\n\n file_1 = open('data/track2/descriptionid_tokensid.txt', 'r')\n file_2 = open('data/track2/purchasedkeywordid_tokensid.txt', 'r')\n file_3 = open('data/track2/queryid_tokensid.txt', 'r')\n file_4 = open('data/track2/titleid_tokensid.txt', 'r')\n file_5 = open('data/track2/userid_profile.txt', 'r')\n\n for line in file_1:\n new_info = parse_line_with_slash(line)\n descriptionid_tokensid.append(new_info)\n\n for line in file_2:\n new_info = parse_line_with_slash(line)\n purchasedkeywordid_tokensid.append(new_info)\n\n for line in file_3:\n new_info = parse_line_with_slash(line)\n queryid_tokensid.append(new_info)\n\n for line in file_4:\n new_info = parse_line_with_slash(line)\n titleid_tokensid.append(new_info)\n\n for line in file_5:\n new_info = line.split()\n userid_profile.append(new_info)\n\n with open('data/track2/training.txt') as file:\n head = [next(file) for _ in range(10)]\n train = np.array(list(map(lambda x: x.split(), head)))\n\n data = []\n for line in train:\n AdID = line(3)\n QueryID = int(line[7])\n KeywordID = int(line[8])\n TitleID = int(line[9])\n DescriptionID = int(line[10])\n UserID = int(line[11])\n assert int(queryid_tokensid[QueryID][0]) == QueryID\n assert int(purchasedkeywordid_tokensid[KeywordID][0]) == KeywordID\n assert int(titleid_tokensid[TitleID][0]) == TitleID\n assert int(descriptionid_tokensid[DescriptionID][0]) == DescriptionID\n user_info = [-1, -1]\n if UserID != 0:\n assert int(userid_profile[UserID][0]) == UserID\n user_info = userid_profile[UserID][1]\n\n data.append([AdID] + user_info + queryid_tokensid[QueryID][1] + purchasedkeywordid_tokensid[KeywordID][1] +\n titleid_tokensid[TitleID][1] + descriptionid_tokensid[DescriptionID][1])\n\n file_1.close()\n file_2.close()\n file_3.close()\n file_4.close()\n file_5.close()\n\n path = 'data/track2/my_data.txt'\n file = open(path, 'w')\n for line in data:\n s = ' '.join(line)\n file.write(s + '\\n')\n file.close()\n return path\n\n\ndef do_binary_vectors(path, size):\n file = open(path, 'r')\n data = []\n for line in file:\n split_line = line.split()\n context = np.zeros(size + 1)\n context[0] = int(split_line[0]) # context[0] = adId, context[1:3] = gender, context[4:10] - age\n gender = int(split_line[1])\n age = int(split_line[2])\n context[gender + 1] = 1\n context[age + 4] = 1\n for num in split_line[3:]:\n context[int(num) + 10] = 1\n data.append(context)\n return data\n\n\n# It is a bad function. It will be deleted later.\n\ndef create_data_from_training_file(path):\n with open(path) as file:\n head = [next(file) for _ in range(1000000)]\n train = np.array(list(map(lambda x: x.split(), head)))\n\n df = pd.DataFrame(train,\n columns=['Click', 'Impression', 'DisplayURL', 'AdID', 'AdvertiserID', 'Depth', 'Position',\n 'QueryID',\n 'KeywordID', 'TitleID', 'DescriptionID', 'UserID'])\n\n pd.options.display.max_columns = 12\n print(df)\n data = []\n\n # for t, row in df.iterrows():\n # x = row['UserID']\n # a = row['AdID']\n # r = compute_reward(x, a, 0.8)\n # data.append((x, a, r))\n\n return data\n"
] |
[
[
"pandas.DataFrame",
"numpy.zeros"
]
] |
RobinRojowiec/stopword-collection
|
[
"4fa3665aa9e0e1e34d9d44afc3bf7ee2cb0da5ed"
] |
[
"analyze.py"
] |
[
"\"\"\"\n\nIDE: PyCharm\nProject: corpus-analysis\nAuthor: Robin\nFilename: analyze\nDate: 13.01.2020\n\n\"\"\"\nimport spacy\n\nfrom util import load_dict\nfrom paths import DIAGRAMS, DICTS\nimport re\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport math\nfrom tqdm import tqdm\n\n# analyze quality\nnlp = spacy.load(\"de_core_news_sm\")\ntotal_frequency: dict = load_dict(DICTS + '/total_frequency.json')\ndocument_frequency: dict = load_dict(DICTS + '/document_frequency.json')\ntotal_docs = 10000\nmax_freq = sum(list(item[1] for item in total_frequency.items()))\n\n\n# visualize\ndef count_bar_chart(counts, title):\n data: [] = list(counts.items())\n data.sort(key=lambda x: x[1], reverse=True)\n data = data[:20]\n\n objects = [x[0] for x in data]\n y_pos = np.arange(len(objects))\n performance = [x[1] / total_docs for x in data]\n\n plt.bar(y_pos, performance, align='center', alpha=0.5)\n plt.xticks(y_pos, objects, rotation='vertical')\n plt.ylabel('relative frequency')\n plt.title(title)\n\n plt.savefig(DIAGRAMS + '/' + title.replace(' ', '_').lower() + \".png\", format='png')\n plt.clf()\n\n\ncount_bar_chart(total_frequency, \"Total frequency\")\ncount_bar_chart(document_frequency, \"Document frequency\")\n\n# generate lists\ndfs: [] = list([item[0], item[1]] for item in document_frequency.items())\n\nword_pattern = re.compile('\\\\w+', flags=re.IGNORECASE)\ndfs = list(filter(lambda x: word_pattern.match(x[0]), dfs))\n\n# calculate information score\nmax_stop_words = 0\nfor token_df in tqdm(dfs):\n # token_df[1] = (total_frequency[token_df[0]]/max_freq)*math.log(total_docs / token_df[1])\n token_df[1] = math.log(total_docs / token_df[1])\n # token_df[1] = document_frequency[token_df[0]]#/max_freq\n\n if nlp(token_df[0])[0].is_stop:\n max_stop_words += 1\n\ndfs.sort(key=lambda x: x[1], reverse=False)\n\ndfreq_list = [x[1] for x in dfs]\nprint(\"Max: %.05f, Min: %.05f, Median:%.05f \" % (max(dfreq_list), min(dfreq_list), np.median(dfreq_list)))\n\nlimit = 200\nstopword_list = [token_df[0] for token_df in dfs[:limit]]\n\ncorrect = 0\ntotal = 0.0\nfor stopword in stopword_list:\n word = nlp(stopword)\n if word[0].is_stop:\n correct += 1\n total += 1\n\nwith open(DICTS + '/stopword_list_ger.dict', 'w+', encoding='utf-8') as dict_file:\n for word in stopword_list:\n dict_file.write(word + '\\n')\nprint(\"Total Stopwords: %i, Accuracy: %.02f, Recall: %.02f\" % (total, correct / total, correct / max_stop_words))\n"
] |
[
[
"numpy.median",
"matplotlib.pyplot.title",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.bar",
"matplotlib.pyplot.xticks"
]
] |
avmehta/frcnntest
|
[
"1f2cd9b68af942ef3b9b78ec97ce2ff496c546ee"
] |
[
"tf_frcnn/lib/layer_utils/generate_anchors.py"
] |
[
"# --------------------------------------------------------\n# Faster R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick and Sean Bell\n# --------------------------------------------------------\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\n\n\ndef generate_anchors(base_size=16, ratios=[0.5, 1, 2],\n scales=2 ** np.arange(3, 6)):\n \"\"\"\n Generate anchor (reference) windows by enumerating aspect ratios X\n scales wrt a reference (0, 0, 15, 15) window.\n \"\"\"\n\n base_anchor = np.array([1, 1, base_size, base_size]) - 1\n ratio_anchors = _ratio_enum(base_anchor, ratios)\n anchors = np.vstack([_scale_enum(ratio_anchors[i, :], scales)\n for i in range(ratio_anchors.shape[0])])\n return anchors\n\n\ndef _whctrs(anchor):\n \"\"\"\n Return width, height, x center, and y center for an anchor (window).\n \"\"\"\n\n w = anchor[2] - anchor[0] + 1\n h = anchor[3] - anchor[1] + 1\n x_ctr = anchor[0] + 0.5 * (w - 1)\n y_ctr = anchor[1] + 0.5 * (h - 1)\n return w, h, x_ctr, y_ctr\n\n\ndef _mkanchors(ws, hs, x_ctr, y_ctr):\n \"\"\"\n Given a vector of widths (ws) and heights (hs) around a center\n (x_ctr, y_ctr), output a set of anchors (windows).\n \"\"\"\n\n ws = ws[:, np.newaxis]\n hs = hs[:, np.newaxis]\n anchors = np.hstack((x_ctr - 0.5 * (ws - 1),\n y_ctr - 0.5 * (hs - 1),\n x_ctr + 0.5 * (ws - 1),\n y_ctr + 0.5 * (hs - 1)))\n return anchors\n\n\ndef _ratio_enum(anchor, ratios):\n \"\"\"\n Enumerate a set of anchors for each aspect ratio wrt an anchor.\n \"\"\"\n\n w, h, x_ctr, y_ctr = _whctrs(anchor)\n size = w * h\n size_ratios = size / ratios\n ws = np.round(np.sqrt(size_ratios))\n hs = np.round(ws * ratios)\n anchors = _mkanchors(ws, hs, x_ctr, y_ctr)\n return anchors\n\n\ndef _scale_enum(anchor, scales):\n \"\"\"\n Enumerate a set of anchors for each scale wrt an anchor.\n \"\"\"\n\n w, h, x_ctr, y_ctr = _whctrs(anchor)\n ws = w * scales\n hs = h * scales\n anchors = _mkanchors(ws, hs, x_ctr, y_ctr)\n return anchors\n\n\nif __name__ == '__main__':\n import time\n\n t = time.time()\n a = generate_anchors()\n print(time.time() - t)\n print(a)\n from IPython import embed;\n\n embed()\n"
] |
[
[
"numpy.array",
"numpy.round",
"numpy.arange",
"numpy.sqrt",
"numpy.hstack"
]
] |
CarlosHernandezP/BCN-20k
|
[
"73630c7420d10002f84642e222a77846f0d59161"
] |
[
"modelling/model.py"
] |
[
"import torch\nimport torch.nn as nn\nimport torchvision.models as models\nfrom efficientnet_pytorch import EfficientNet\n\nclass CEEffNet(nn.Module):\n \"\"\"encoder + classifier\"\"\"\n def __init__(self, num_classes=2, model_name='effb0'):\n super(CEEffNet, self).__init__()\n\n self.encoder = choose_model(model_name=model_name)\n dim_in = self.encoder._fc.in_features\n self.encoder._fc = nn.Identity()\n self.fc = nn.Sequential(\n nn.Dropout(p=0.4),\n nn.Linear(dim_in, int(dim_in/2)),\n Swish_Module(),\n nn.Dropout(p=0.4),\n nn.Linear(int(dim_in/2), num_classes))\n\n def forward(self, x):\n feat = self.encoder(x)\n \n return self.fc(feat)\n\n\nclass CEResNet(nn.Module):\n \"\"\"encoder + classifier\"\"\"\n def __init__(self, num_classes=2, model_name='resnet50'):\n super(CEResNet, self).__init__()\n self.encoder = choose_model(model_name=model_name)\n dim_in = self.encoder.fc.in_features\n\n self.encoder.fc = nn.Identity()\n self.fc = nn.Sequential(\n nn.Dropout(p=0.4),\n nn.Linear(dim_in, int(dim_in/2)),\n nn.ReLU(inplace=True),\n nn.Dropout(p=0.4),\n nn.Linear(int(dim_in/2), num_classes))\n\n def forward(self, x):\n feat = self.encoder(x)\n return self.fc(self.encoder(x))\n\ndef choose_model(model_name : str) -> nn.Module:\n if 'res' in model_name:\n if '18' in model_name:\n feature_extractor = models.resnet18(pretrained=True)\n elif '34' in model_name:\n feature_extractor = models.resnet34(pretrained=True)\n elif '50' in model_name:\n feature_extractor = models.resnet50(pretrained=True)\n else:\n raise NotImplementedError(\"The feature extractor cannot be instantiated: model asked -> {} does not exist\".format(model_name))\n\n elif 'eff' in model_name:\n if 'b0' in model_name:\n feature_extractor = EfficientNet.from_pretrained('efficientnet-b0', num_classes=2)\n elif 'b1' in model_name:\n feature_extractor = EfficientNet.from_pretrained('efficientnet-b1', num_classes=2)\n elif 'b2' in model_name:\n feature_extractor = EfficientNet.from_pretrained('efficientnet-b2', num_classes=2)\n else:\n raise NotImplementedError(\"The feature extractor cannot be instantiated: model asked -> {} does not exist\".format(model_name))\n else:\n raise NotImplementedError(\"The feature extractor cannot be instantiated: model asked -> {} does not exist\".format(model_name))\n \n return feature_extractor\n\nsigmoid = nn.Sigmoid()\nclass Swish(torch.autograd.Function):\n @staticmethod\n def forward(ctx, i):\n result = i * sigmoid(i)\n ctx.save_for_backward(i)\n return result\n\n @staticmethod \n def backward(ctx, grad_output):\n i = ctx.saved_variables[0]\n sigmoid_i = sigmoid(i)\n return grad_output * (sigmoid_i * (1 + i * (1 - sigmoid_i)))\n\nclass Swish_Module(nn.Module):\n def forward(self, x):\n return Swish.apply(x)\n"
] |
[
[
"torch.nn.ReLU",
"torch.nn.Identity",
"torch.nn.Dropout",
"torch.nn.Sigmoid"
]
] |
zoubaihan/SEGCN
|
[
"3d5b60e09018b162bcad6f91a11512cd815765cc"
] |
[
"segcn/layers.py"
] |
[
"import math\n\nimport torch\n\nfrom torch.nn.parameter import Parameter\nfrom torch.nn.modules.module import Module\n\n\nclass SparseMM(torch.autograd.Function):\n \"\"\"\n Sparse x dense matrix multiplication with autograd support.\n\n Implementation by Soumith Chintala:\n https://discuss.pytorch.org/t/\n does-pytorch-support-autograd-on-sparse-matrix/6156/7\n \"\"\"\n\n def __init__(self, sparse):\n super(SparseMM, self).__init__()\n self.sparse = sparse\n\n def forward(self, dense):\n return torch.mm(self.sparse, dense)\n\n def backward(self, grad_output):\n grad_input = None\n if self.needs_input_grad[0]:\n grad_input = torch.mm(self.sparse.t(), grad_output)\n return grad_input\n\n\nclass GraphConvolution(Module):\n \"\"\"\n Simple GCN layer, similar to https://arxiv.org/abs/1609.02907\n \"\"\"\n\n def __init__(self, in_features, out_features, bias=True):\n super(GraphConvolution, self).__init__()\n self.in_features = in_features\n self.out_features = out_features\n self.weight = Parameter(torch.FloatTensor(in_features, out_features))\n if bias:\n self.bias = Parameter(torch.FloatTensor(out_features))\n else:\n self.register_parameter('bias', None)\n self.reset_parameters()\n\n def reset_parameters(self):\n stdv = 1. / math.sqrt(self.weight.size(1))\n self.weight.data.uniform_(-stdv, stdv)\n if self.bias is not None:\n self.bias.data.uniform_(-stdv, stdv)\n\n def forward(self, input, adj):\n support = torch.mm(input, self.weight)\n output = SparseMM(adj)(support)\n if self.bias is not None:\n return output + self.bias\n else:\n return output\n\n def __repr__(self):\n return self.__class__.__name__ + ' (' \\\n + str(self.in_features) + ' -> ' \\\n + str(self.out_features) + ')'\n"
] |
[
[
"torch.FloatTensor",
"torch.mm"
]
] |
hassanobeid1994/tr_b_causal_2020
|
[
"1ffaeb7dcefccf5e1f24c459e9a2f140b2a052a5"
] |
[
"src/causal2020/observables/distfit.py"
] |
[
"\"\"\"\nFunctions used in the fitting of distributions\nto variables to be simulated.\n\"\"\"\nfrom collections import defaultdict\n\nimport numpy as np\nimport pandas as pd\nfrom fitter import Fitter\n\n# Functions to replace code within\n# DistNodeNoParent\n# Function for checking length\n\n\ndef is_unique(var_values):\n \"\"\"\n Checks whether a variable has one unique value.\n \"\"\"\n return len(var_values.unique()) == 1\n\n\n# def is_empirical(var_type):\n# \"\"\"\n# Checks whether the variable type for the\n# variable of interest is to be taken\n# as a constant value or as numerical values.\n# \"\"\"\n# return var_type in ['constant', 'numerical']\n\n\ndef is_constant(var_type): # to be rethought\n \"\"\"\n Checks whether a variable has a constant\n value.\n \"\"\"\n return var_type == \"constant\"\n\n\ndef is_empirical(var_type):\n \"\"\"\n Checks whether the variable type for the\n variable of interest is to be taken\n as a constant value or as numerical values.\n \"\"\"\n return var_type == \"empirical\"\n\n\ndef is_categorical(var_type):\n \"\"\"\n Checks whether the variable type for the\n variable of interest is categorical.\n \"\"\"\n return var_type == \"categorical\"\n\n\ndef get_alt_specific_variable_name(var_name, alt_name):\n \"\"\"\n Gets the alternative specific variable,\n returns a string starting with variable name and\n ending with alternative name.\n \"\"\"\n return var_name + \"_\" + alt_name\n\n\ndef get_constant_dist(var, var_val, alt_name=None):\n \"\"\"\n Retrives the constant 'distribution' of a\n constant variable.\n \"\"\"\n constant_dict = defaultdict(dict)\n # Add name of alternative to variable and store distriburion & parameters\n var_name = (\n var\n if alt_name is None\n else get_alt_specific_variable_name(var, alt_name)\n )\n constant_dict[var_name][\"distribution\"] = \"constant\"\n constant_dict[var_name][\"parameters\"] = var_val.unique()\n return constant_dict\n\n\ndef get_empirical_dist(var, var_val, alt_name=None):\n \"\"\"\n Retrives the empirical values of the alternative\n specific variable of interest as its distribution.\n \"\"\"\n empir_dict = defaultdict(dict)\n # Add name of alternative to variable and store distriburion & parameters\n var_name = (\n var\n if alt_name is None\n else get_alt_specific_variable_name(var, alt_name)\n )\n empir_dict[var_name][\"distribution\"] = \"empirical\"\n empir_dict[var_name][\"parameters\"] = np.array(var_val)\n return empir_dict\n\n\ndef get_categorical_dist(var, var_val, alt_name=None):\n \"\"\"\n Retrives the unique values and the proportions\n of observed values for a categorical alternative\n specific variables.\n \"\"\"\n categ_dict = defaultdict(dict)\n # If more than one category, compute the frequency of values\n # and store as parameters\n # Add name of alternative to variable and store distriburion & parameters\n var_name = (\n var\n if alt_name is None\n else get_alt_specific_variable_name(var, alt_name)\n )\n categ_dict[var_name][\"distribution\"] = \"categorical\"\n np_array_range = np.arange(var_val.max() + 1)\n array_bincount = np.bincount(var_val)\n probs = array_bincount / len(var_val)\n categ_dict[var_name][\"parameters\"] = [np_array_range, probs]\n return categ_dict\n\n\ndef get_continuous_dist(var, var_val, cont_dists, alt_name=None):\n \"\"\"\n Retrives the distribution of continuous alternative\n specific variables using the Fitter package.\n \"\"\"\n cont_dict = defaultdict(dict)\n # Use the Fitter library to fit distributions\n # to the data\n fitter_object = Fitter(\n data=var_val, distributions=cont_dists, timeout=60\n )\n fitter_object.fit()\n # Get the best distribution and store in dictionary\n BestDict = fitter_object.get_best()\n # Add name of alternative to variable and store distriburion & parameters\n var_name = (\n var\n if alt_name is None\n else get_alt_specific_variable_name(var, alt_name)\n )\n cont_dict[var_name][\"distribution\"] = list(BestDict.items())[0][0]\n cont_dict[var_name][\"parameters\"] = list(BestDict.items())[0][1]\n return cont_dict\n\n\ndef get_distribution_dicts(var, var_type, var_val, cont_dists, alt_name=None):\n \"\"\"\n Helper function to generate a distribution dictionary\n for the variable specified.\n \"\"\"\n # If data is categorical\n if is_empirical(var_type):\n # If only one category\n if is_unique(var_val):\n # Add name of alternative to variable\n # and store distriburion & parameters\n dist_dic = get_constant_dist(var, var_val, alt_name)\n else:\n dist_dic = get_empirical_dist(var, var_val, alt_name)\n elif is_categorical(var_type):\n if is_unique(var_val):\n dist_dic = get_constant_dist(var, var_val, alt_name)\n else:\n dist_dic = get_categorical_dist(var, var_val, alt_name)\n else:\n # If data is not categorical but has one unique value\n if is_unique(var_val):\n dist_dic = get_constant_dist(var, var_val, alt_name)\n # If data is not categorical but has more than one unique value\n else:\n dist_dic = get_continuous_dist(var, var_val, alt_name, cont_dists)\n return dist_dic\n\n\n############################################\n# Functions to replace functionality for\n# fitting distributions for variables\n# specific variables that have no parents\n# in the causal graph.\n############################################\n\n\ndef ind_spec_dist(data_long, obs_id_col, ind_spec, var_types, cont_dists):\n \"\"\"\n Function that retrieves distributions for all individual\n specific variables.\n \"\"\"\n ind_spec_dict = defaultdict(dict)\n for ind_var in ind_spec:\n # generate array of values for individual specific variable\n var_val = (\n data_long[[obs_id_col, ind_var]]\n .drop_duplicates(obs_id_col, inplace=False)\n .loc[:, ind_var]\n .reset_index(drop=True)\n )\n # Get distribution of variable\n var_type = var_types[ind_var]\n ind_var_dic = get_distribution_dicts(\n ind_var, var_type, var_val, cont_dists\n )\n ind_spec_dict.update(ind_var_dic)\n return ind_spec_dict\n\n\ndef alt_spec_dist(\n data_long, alt_id_col, alt_spec_dic, var_types, alt_name_dic, cont_dists\n):\n \"\"\"\n Function that retrieves distributions for all alternative\n specific variables.\n \"\"\"\n all_alt_spec_var_dic = defaultdict(dict)\n for alt_id in data_long[alt_id_col].unique():\n # Store data for specific alternative (mode)\n alt_data = data_long.loc[data_long[alt_id_col] == alt_id]\n alt_spec_var_dic = defaultdict(dict)\n # Loop around the alternative specific\n # variables in the input dictionary\n alt_name = alt_name_dic[alt_id]\n for alt_var in alt_spec_dic[alt_id]:\n var_val = alt_data[alt_var]\n var_type = var_types[alt_var]\n alt_spec_var_dist = get_distribution_dicts(\n alt_var, var_type, var_val, alt_name, cont_dists\n )\n alt_spec_var_dic.update(alt_spec_var_dist)\n all_alt_spec_var_dic.update(alt_spec_var_dic)\n return all_alt_spec_var_dic\n\n\ndef trip_spec_dist(data_long, obs_id_col, trip_spec, var_types, cont_dists):\n \"\"\"\n Function that retrieves distributions for all trip\n specific variables.\n \"\"\"\n # Trip Specific Variable (maybe combine with individual specific variables)\n # Loop around trip (observation) specific variables\n trip_spec_dict = defaultdict(dict)\n for trip_var in trip_spec:\n # generate array of values for trip specific variable\n var_val = (\n data_long[[obs_id_col, trip_var]]\n .drop_duplicates(obs_id_col, inplace=False)\n .loc[:, trip_var]\n .reset_index(drop=True)\n )\n var_type = var_types[trip_var]\n # If data is to be taken as empirical values\n trip_spec_var_dist = get_distribution_dicts(\n trip_var, var_type, var_val, cont_dists\n )\n trip_spec_dict.update(trip_spec_var_dist)\n return trip_spec_dict\n\n\n# Define the main function\ndef get_dist_node_no_parent(\n data_long,\n alt_id_col,\n obs_id_col,\n alt_spec_dic,\n alt_name_dic,\n ind_spec,\n trip_spec,\n var_types,\n cont_dists=None,\n):\n \"\"\"\n Function to find the distribution of specific variables\n from a long format dataset.\n\n Parameters\n ----------\n data_long: Pandas DataFrame\n Dataset in long format from which variable\n distribution is to be found.\n\n alt_id_col: string\n Name of the column with alternative ids.\n\n obs_id_col: string\n Name of the column with observation ids.\n\n alt_spec_dic: dictionary\n Dictionary with keys as the ordered number\n of alternatives, and the value for each key\n is a list of strings representing the name of\n variables without parents per alternative.\n\n alt_name_dic: dictionary\n Dictionary with keys as the ordered number\n of alternatives, and the value for each key\n is a string representing the name of the\n alternative.\n\n ind_spec: list\n List containing strings of the names of\n individual specific variables.\n\n trip_spec: list\n List containing string of the names of\n trip specific variables.\n\n var_types: dictionary\n Dictionary with keys as strings of names of variables\n from long format dataset, and values for each key are\n the type of variables (e.g.: 'categorical vs. continuous').\n\n cont_dists: list\n List of continuous RVs distribution names from scipy.\n\n Returns\n -------\n a nested dictionary with keys as variable names and values\n as dictionaries containing both the distribution name and\n its parameters.\n \"\"\"\n params_dict = defaultdict(dict)\n\n # Code for Individual Specific Variables\n print(\"Getting Distributions of Individual Specific Variables...\")\n print(\"---------------------------------------------------------\")\n ind_spec_dic_params = ind_spec_dist(\n data_long, obs_id_col, ind_spec, var_types, cont_dists\n )\n params_dict.update(ind_spec_dic_params)\n print(\"Done...\")\n\n # Code for Alternative Specific Variables\n # Loop around the different available alternatives\n print(\"Getting Distributions of Alternative Specific Variables...\")\n print(\"----------------------------------------------------------\")\n alt_spec_dic_params = alt_spec_dist(\n data_long,\n alt_id_col,\n alt_spec_dic,\n var_types,\n alt_name_dic,\n cont_dists,\n )\n params_dict.update(alt_spec_dic_params)\n print(\"Done...\")\n\n # Trip Specific Variable (maybe combine with individual specific variables)\n # Loop around trip (observation) specific variables\n print(\"Getting Distributions of Trip Specific Variables...\")\n print(\"---------------------------------------------------------\")\n trip_spec_dic_params = trip_spec_dist(\n data_long, obs_id_col, trip_spec, var_types, cont_dists\n )\n params_dict.update(trip_spec_dic_params)\n print(\"Done...\")\n\n return params_dict\n"
] |
[
[
"numpy.bincount",
"numpy.array"
]
] |
jphacks/D_2003
|
[
"60a5684d549862e85bdf758069518702d9925a48",
"60a5684d549862e85bdf758069518702d9925a48",
"60a5684d549862e85bdf758069518702d9925a48"
] |
[
"YOLO/.history/pytorch-yolo-v3/video_demo_20201105153325.py",
"YOLO/.history/pytorch-yolo-v3/video_demo_v1_20201106032031.py",
"YOLO/.history/pytorch-yolo-v3/video_demo_20201105145255.py"
] |
[
"from __future__ import division\nimport time\nimport torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\nimport numpy as np\nimport cv2\nfrom util import *\nfrom darknet import Darknet\nfrom preprocess import prep_image, inp_to_image\nimport pandas as pd\nimport random\nimport argparse\nimport pickle as pkl\n\nimport requests\nfrom requests.auth import HTTPDigestAuth\n\nimport io\nfrom PIL import Image, ImageDraw, ImageFilter\n# import play\n\n#from pygame import mixer\n#import winsound\n\ncamera_name = {\n \"north\":0,\n \"south\":2,\n \"east\":1,\n \"west\":3,\n}\n\n\ndef prep_image(img, inp_dim):\n # CNNに通すために画像を加工する\n orig_im = img\n dim = orig_im.shape[1], orig_im.shape[0]\n img = cv2.resize(orig_im, (inp_dim, inp_dim))\n img_ = img[:,:,::-1].transpose((2,0,1)).copy()\n img_ = torch.from_numpy(img_).float().div(255.0).unsqueeze(0)\n return img_, orig_im, dim\n\ndef count(x, img, count):\n # 画像に結果を描画\n c1 = tuple(x[1:3].int())\n c2 = tuple(x[3:5].int())\n cls = int(x[-1])\n label = \"{0}\".format(classes[cls])\n print(\"label:\\n\", label)\n # 人数カウント\n if(label=='no-mask'):\n count+=1\n print(count)\n\n return count\n\ndef write(x, img,camId):\n global count\n global point\n p = [0,0]\n # 画像に結果を描画\n c1 = tuple(x[1:3].int())\n c2 = tuple(x[3:5].int())\n cls = int(x[-1])\n print(camId, \"_c1:\",c1)\n print(camId, \"_c2:\",c2)\n label = \"{0}\".format(classes[cls])\n print(\"label:\", label)\n # 人数カウント\n if(label=='no-mask'):\n count+=1\n print(count)\n\n color = random.choice(colors)\n cv2.rectangle(img, c1, c2,color, 1)\n t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_PLAIN, 1 , 1)[0]\n c2 = c1[0] + t_size[0] + 3, c1[1] + t_size[1] + 4\n cv2.rectangle(img, c1, c2,color, -1)\n cv2.putText(img, label, (c1[0], c1[1] + t_size[1] + 4), cv2.FONT_HERSHEY_PLAIN, 1, [225,255,255], 1);\n\n p[0] = (c2[0]-c1[0])/2\n p[1] = (c2[1]-c1[1])/2\n point[camId].append(p)\n print(\"point0\",point[0])\n print(\"point1\",point[1])\n\n return img\n\ndef arg_parse():\n # モジュールの引数を作成\n parser = argparse.ArgumentParser(description='YOLO v3 Cam Demo') # ArgumentParserで引数を設定する\n parser.add_argument(\"--confidence\", dest = \"confidence\", help = \"Object Confidence to filter predictions\", default = 0.25)\n # confidenceは信頼性\n parser.add_argument(\"--nms_thresh\", dest = \"nms_thresh\", help = \"NMS Threshhold\", default = 0.4)\n # nms_threshは閾値\n\n parser.add_argument(\"--reso\", dest = 'reso', help =\n \"Input resolution of the network. Increase to increase accuracy. Decrease to increase speed\",\n default = \"160\", type = str)\n # resoはCNNの入力解像度で、増加させると精度が上がるが、速度が低下する。\n return parser.parse_args() # 引数を解析し、返す\n\ndef cvpaste(img, imgback, x, y, angle, scale):\n # x and y are the distance from the center of the background image\n\n r = img.shape[0]\n c = img.shape[1]\n rb = imgback.shape[0]\n cb = imgback.shape[1]\n hrb=round(rb/2)\n hcb=round(cb/2)\n hr=round(r/2)\n hc=round(c/2)\n\n # Copy the forward image and move to the center of the background image\n imgrot = np.zeros((rb,cb,3),np.uint8)\n imgrot[hrb-hr:hrb+hr,hcb-hc:hcb+hc,:] = img[:hr*2,:hc*2,:]\n\n # Rotation and scaling\n M = cv2.getRotationMatrix2D((hcb,hrb),angle,scale)\n imgrot = cv2.warpAffine(imgrot,M,(cb,rb))\n # Translation\n M = np.float32([[1,0,x],[0,1,y]])\n imgrot = cv2.warpAffine(imgrot,M,(cb,rb))\n\n # Makeing mask\n imggray = cv2.cvtColor(imgrot,cv2.COLOR_BGR2GRAY)\n ret, mask = cv2.threshold(imggray, 10, 255, cv2.THRESH_BINARY)\n mask_inv = cv2.bitwise_not(mask)\n\n # Now black-out the area of the forward image in the background image\n img1_bg = cv2.bitwise_and(imgback,imgback,mask = mask_inv)\n\n # Take only region of the forward image.\n img2_fg = cv2.bitwise_and(imgrot,imgrot,mask = mask)\n\n # Paste the forward image on the background image\n imgpaste = cv2.add(img1_bg,img2_fg)\n\n return imgpaste\n\ndef hconcat_resize_min(im_list, interpolation=cv2.INTER_CUBIC):\n h_min = min(im.shape[0] for im in im_list)\n im_list_resize = [cv2.resize(im, (int(im.shape[1] * h_min / im.shape[0]), h_min), interpolation=interpolation)\n for im in im_list]\n return cv2.hconcat(im_list_resize)\n\n# def beep(freq, dur=100):\n# winsound.Beep(freq, dur)\n\nif __name__ == '__main__':\n #学習前YOLO\n # cfgfile = \"cfg/yolov3.cfg\" # 設定ファイル\n # weightsfile = \"weight/yolov3.weights\" # 重みファイル\n # classes = load_classes('data/coco.names') # 識別クラスのリスト\n\n #マスク学習後YOLO\n cfgfile = \"cfg/mask.cfg\" # 設定ファイル\n weightsfile = \"weight/mask_1500.weights\" # 重みファイル\n classes = load_classes('data/mask.names') # 識別クラスのリスト\n\n\n num_classes = 80 # クラスの数\n\n args = arg_parse() # 引数を取得\n confidence = float(args.confidence) # 信頼性の設定値を取得\n nms_thesh = float(args.nms_thresh) # 閾値を取得\n start = 0\n CUDA = torch.cuda.is_available() # CUDAが使用可能かどうか\n\n num_classes = 80 # クラスの数\n bbox_attrs = 5 + num_classes\n max = 0 #限界人数\n num_camera = 2 #camera数\n model = [[] for i in range(num_camera)]\n inp_dim = [[] for i in range(num_camera)]\n cap = [[] for i in range(num_camera)]\n ret = [[] for i in range(num_camera)]\n frame = [[] for i in range(num_camera)]\n img = [[] for i in range(num_camera)]\n orig_im = [[] for i in range(num_camera)]\n dim = [[] for i in range(num_camera)]\n output0 = []\n output1 = []\n output2 = []\n output3 = []\n\n point = [[] for i in range(num_camera)]\n # output = [[] for i in range(num_camera)]\n # output = torch.tensor(output)\n # print(\"output_shape\\n\", output.shape)\n\n for i in range(num_camera):\n model[i] = Darknet(cfgfile) #model1の作成\n model[i].load_weights(weightsfile) # model1に重みを読み込む\n\n model[i].net_info[\"height\"] = args.reso\n inp_dim[i] = int(model[i].net_info[\"height\"])\n\n assert inp_dim[i] % 32 == 0\n assert inp_dim[i] > 32\n\n #mixer.init() #初期化\n\n if CUDA:\n for i in range(num_camera):\n model[i].cuda() #CUDAが使用可能であればcudaを起動\n\n for i in range(num_camera):\n model[i].eval()\n\n cap[0] = cv2.VideoCapture(0) #カメラを指定（USB接続）\n cap[1] = cv2.VideoCapture(1) #カメラを指定（USB接続）\n # cap = cv2.VideoCapture(\"movies/sample.mp4\")\n #cap = cv2.VideoCapture(\"movies/one_v2.avi\")\n\n # Use the next line if your camera has a username and password\n # cap = cv2.VideoCapture('protocol://username:password@IP:port/1')\n #cap = cv2.VideoCapture('rtsp://admin:admin@192.168.11.4/1') #（ネットワーク接続）\n #cap = cv2.VideoCapture('rtsp://admin:admin@192.168.11.4/80')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.4:80/video')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.4/camera-cgi/admin/recorder.cgi?action=start&id=samba')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.4/recorder.cgi?action=start&id=samba')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.5:80/snapshot.jpg?user=admin&pwd=admin&strm=0')\n print('-1')\n\n #assert cap.isOpened(), 'Cannot capture source' #カメラが起動できたか確認\n\n img1 = cv2.imread(\"images/phase_1.jpg\")\n img2 = cv2.imread(\"images/phase_2.jpg\")\n img3 = cv2.imread(\"images/phase_2_red.jpg\")\n img4 = cv2.imread(\"images/phase_3.jpg\")\n #mixer.music.load(\"voice/voice_3.m4a\")\n #print(img1)\n frames = 0\n count_frame = 0 #フレーム数カウント\n flag = 0 #密状態（0：疎密，1：密入り）\n start = time.time()\n print('-1')\n while (cap[i].isOpened() for i in range(num_camera)): #カメラが起動している間\n count=0 #人数をカウント\n point = [[] for i in range(num_camera)]\n for i in range(num_camera):\n ret[i], frame[i] = cap[i].read() #キャプチャ画像を取得\n if (ret[i] for i in range(num_camera)):\n # 解析準備としてキャプチャ画像を加工\n for i in range(num_camera):\n img[i], orig_im[i], dim[i] = prep_image(frame[i], inp_dim[i])\n\n if CUDA:\n for i in range(num_camera):\n im_dim[i] = im_dim[i].cuda()\n img[i] = img[i].cuda()\n\n # for i in range(num_camera):\n # output[i] = model[i](Variable(img[i]), CUDA)\n output0 = model[0](Variable(img[0]), CUDA)\n output1 = model[1](Variable(img[1]), CUDA)\n # output2 = model[2](Variable(img[2]), CUDA)\n # output3 = model[3](Variable(img[3]), CUDA)\n\n #print(\"output:\\n\", output)\n # output[i] = write_results(output[i], confidence, num_classes, nms = True, nms_conf = nms_thesh)\n output0 = write_results(output0, confidence, num_classes, nms = True, nms_conf = nms_thesh)\n output1 = write_results(output1, confidence, num_classes, nms = True, nms_conf = nms_thesh)\n # output2 = write_results(output2, confidence, num_classes, nms = True, nms_conf = nms_thesh)\n # output3 = write_results(output3, confidence, num_classes, nms = True, nms_conf = nms_thesh)\n # print(\"output\", i, \":\\n\", output[i])\n # print(output.shape)\n \"\"\"\n # FPSの表示\n if (type(output[i]) == int for i in range(num_camera)):\n print(\"表示\")\n frames += 1\n print(\"FPS of the video is {:5.2f}\".format( frames / (time.time() - start)))\n\n # qキーを押すとFPS表示の終了\n key = cv2.waitKey(1)\n if key & 0xFF == ord('q'):\n break\n continue\n for i in range(num_camera):\n output[i][:,1:5] = torch.clamp(output[i][:,1:5], 0.0, float(inp_dim[i]))/inp_dim[i]\n output[i][:,[1,3]] *= frame[i].shape[1]\n output[i][:,[2,4]] *= frame[i].shape[0]\n \"\"\"\n # # FPSの表示\n # if type(output0) == int:\n # print(\"表示\")\n # frames += 1\n # print(\"FPS of the video is {:5.2f}\".format( frames / (time.time() - start)))\n\n # # qキーを押すとFPS表示の終了\n # key = cv2.waitKey(1)\n # if key & 0xFF == ord('q'):\n # break\n # continue\n # for i in range(num_camera):\n output0[:,1:5] = torch.clamp(output0[:,1:5], 0.0, float(inp_dim[i]))/inp_dim[i]\n output0[:,[1,3]] *= frame[0].shape[1]\n output0[:,[2,4]] *= frame[0].shape[0]\n\n output1[:,1:5] = torch.clamp(output1[:,1:5], 0.0, float(inp_dim[i]))/inp_dim[i]\n output1[:,[1,3]] *= frame[1].shape[1]\n output1[:,[2,4]] *= frame[1].shape[0]\n\n # output2[:,1:5] = torch.clamp(output2[:,1:5], 0.0, float(inp_dim[i]))/inp_dim[i]\n # output2[:,[1,3]] *= frame[i].shape[1]\n # output2[:,[2,4]] *= frame[i].shape[0]\n\n # output3[:,1:5] = torch.clamp(output3[:,1:5], 0.0, float(inp_dim[i]))/inp_dim[i]\n # output3[:,[1,3]] *= frame[i].shape[1]\n # output3[:,[2,4]] *= frame[i].shape[0]\n\n\n\n colors = pkl.load(open(\"pallete\", \"rb\"))\n\n #count = lambda x: count(x, orig_im, count) #人数をカウント\n \"\"\"\n for i in range(num_camera):\n list(map(lambda x: write(x, orig_im[i]), output[i]))\n print(\"count:\\n\",count)\n \"\"\"\n # for i in range(num_camera):\n # list(map(lambda x: write(x, orig_im[i]), output))\n list(map(lambda x0: write(x0, orig_im[0],0), output0))\n list(map(lambda x1: write(x1, orig_im[1],1), output1))\n # print(\"x0\",x0)\n # list(map(lambda x2: write(x2, orig_im[2],2), output2))\n # list(map(lambda x3: write(x3, orig_im[3],3), output3))\n # print(\"point0\",point[0])\n # print(\"point1\",point[1])\n\n\n print(\"count:\\n\",count)\n print(\"count_frame\", count_frame)\n\n\n if count > max:\n count_frame += 1\n #print(\"-1\")\n if count_frame <= 50:\n x=0\n y=0\n angle=20\n scale=1.5\n for i in range(num_camera):\n imgpaste = cvpaste(img1, orig_im[i], x, y, angle, scale)\n if flag == 1:\n # play.googlehome()\n flag += 1\n #mixer.music.play(1)\n elif count_frame <= 100:\n x=-30\n y=10\n angle=20\n scale=1.1\n if count_frame%2==1:\n for i in range(num_camera):\n imgpaste = cvpaste(img2, orig_im[i], x, y, angle, scale)\n else:\n for i in range(num_camera):\n imgpaste = cvpaste(img3, orig_im[i], x, y, angle, scale)\n if flag == 2:\n # play.googlehome()\n flag += 1\n else:\n x=-30\n y=0\n angle=20\n scale=1.5\n for i in range(num_camera):\n imgpaste = cvpaste(img4, orig_im[i], x, y, angle, scale)\n if count_frame > 101: #<--2フレームずらす\n print(\"\\007\") #警告音\n time.sleep(3)\n if flag == 3:\n # play.googlehome()\n flag += 1\n # cv2.imshow(\"frame\", imgpaste)\n else:\n count_frame = 0\n flag = 0\n #print(\"-2\")\n # for i in range(num_camera):\n im_h_resize = hconcat_resize_min(orig_im)\n cv2.imshow(\"frame\", im_h_resize )\n # play.googlehome()\n key = cv2.waitKey(1)\n # qキーを押すと動画表示の終了\n if key & 0xFF == ord('q'):\n break\n frames += 1\n print(\"count_frame:\\n\", count_frame)\n print(\"FPS of the video is {:5.2f}\".format( frames / (time.time() - start)))\n\n else:\n break\n\n",
"from __future__ import division\nimport time\nimport torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\nimport numpy as np\nimport cv2\nfrom util import *\nfrom darknet import Darknet\nfrom preprocess import prep_image, inp_to_image\nimport pandas as pd\nimport random\nimport argparse\nimport pickle as pkl\n\nimport requests\nfrom requests.auth import HTTPDigestAuth\n\nimport io\nfrom PIL import Image, ImageDraw, ImageFilter\n\nimport play\n\nimport csv\nimport itertools\nimport math\n\nwith open('csv/Lidar.csv', 'r', encoding=\"utf-8_sig\", newline = '') as f:\n l = csv.reader(f)\n LiDAR = [row for row in l]\n # for row in LiDAR:\n # print(row)\n\nLiDAR_array = np.array(LiDAR)\nLiDAR_array1, LiDAR_array2 = np.split(LiDAR_array, 2, 1)\n#LiDAR = [[int(n) for n in row] for row in LiDAR]\n# LiDAR = [list(map(int, row)) for row in LiDAR]\nLiDAR_array1_int = LiDAR_array1.astype(np.int64)\nLiDAR_array2_float = LiDAR_array2.astype(np.float32)\nLiDAR_array_cast = np.append(LiDAR_array1_int, LiDAR_array2_float, axis = 1)\nLiDAR_list = LiDAR_array_cast.tolist()\n# for i in LiDAR_list:\n# print(i)\nprint(\"LiDAR_len\", type(LiDAR[0][0]))\n\n\n\n\ndef prep_image(img, inp_dim):\n # CNNに通すために画像を加工する\n orig_im = img\n dim = orig_im.shape[1], orig_im.shape[0]\n img = cv2.resize(orig_im, (inp_dim, inp_dim))\n img_ = img[:,:,::-1].transpose((2,0,1)).copy()\n img_ = torch.from_numpy(img_).float().div(255.0).unsqueeze(0)\n return img_, orig_im, dim\n\ndef count(x, img, count):\n # 画像に結果を描画\n c1 = tuple(x[1:3].int())\n c2 = tuple(x[3:5].int())\n cls = int(x[-1])\n label = \"{0}\".format(classes[cls])\n print(\"label:\\n\", label)\n # 人数カウント\n if(label=='no-mask'):\n count+=1\n print(count)\n\n return count\n\ndef write(x, img,camId):\n global count\n global point\n p = [0,0]\n # 画像に結果を描画\n c1 = tuple(x[1:3].int())\n c2 = tuple(x[3:5].int())\n cls = int(x[-1])\n print(camId, \"_c0:\",c1)\n print(camId, \"_c1:\",c2)\n label = \"{0}\".format(classes[cls])\n print(\"label:\", label)\n # 人数カウント\n if(label=='no-mask'):\n count+=1\n print(count)\n\n p[0] = (c2[0]+c1[0])/2\n p[1] = (c2[1]+c1[1])/2\n point[camId].append(p)\n\n\n color = random.choice(colors)\n cv2.rectangle(img, c1, c2,color, 1)\n t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_PLAIN, 1 , 1)[0]\n c2 = c1[0] + t_size[0] + 3, c1[1] + t_size[1] + 4\n cv2.rectangle(img, c1, c2,color, -1)\n cv2.putText(img, label, (c1[0], c1[1] + t_size[1] + 4), cv2.FONT_HERSHEY_PLAIN, 1, [225,255,255], 1);\n\n return img\n\n\ndef arg_parse():\n # モジュールの引数を作成\n parser = argparse.ArgumentParser(description='YOLO v3 Cam Demo') # ArgumentParserで引数を設定する\n parser.add_argument(\"--confidence\", dest = \"confidence\", help = \"Object Confidence to filter predictions\", default = 0.25)\n # confidenceは信頼性\n parser.add_argument(\"--nms_thresh\", dest = \"nms_thresh\", help = \"NMS Threshhold\", default = 0.4)\n # nms_threshは閾値\n\n parser.add_argument(\"--reso\", dest = 'reso', help =\n \"Input resolution of the network. Increase to increase accuracy. Decrease to increase speed\",\n default = \"160\", type = str)\n # resoはCNNの入力解像度で、増加させると精度が上がるが、速度が低下する。\n return parser.parse_args() # 引数を解析し、返す\n\ndef cvpaste(img, imgback, x, y, angle, scale):\n # x and y are the distance from the center of the background image\n\n r = img.shape[0]\n c = img.shape[1]\n rb = imgback.shape[0]\n cb = imgback.shape[1]\n hrb=round(rb/2)\n hcb=round(cb/2)\n hr=round(r/2)\n hc=round(c/2)\n\n # Copy the forward image and move to the center of the background image\n imgrot = np.zeros((rb,cb,3),np.uint8)\n imgrot[hrb-hr:hrb+hr,hcb-hc:hcb+hc,:] = img[:hr*2,:hc*2,:]\n\n # Rotation and scaling\n M = cv2.getRotationMatrix2D((hcb,hrb),angle,scale)\n imgrot = cv2.warpAffine(imgrot,M,(cb,rb))\n # Translation\n M = np.float32([[1,0,x],[0,1,y]])\n imgrot = cv2.warpAffine(imgrot,M,(cb,rb))\n\n # Makeing mask\n imggray = cv2.cvtColor(imgrot,cv2.COLOR_BGR2GRAY)\n ret, mask = cv2.threshold(imggray, 10, 255, cv2.THRESH_BINARY)\n mask_inv = cv2.bitwise_not(mask)\n\n # Now black-out the area of the forward image in the background image\n img1_bg = cv2.bitwise_and(imgback,imgback,mask = mask_inv)\n\n # Take only region of the forward image.\n img2_fg = cv2.bitwise_and(imgrot,imgrot,mask = mask)\n\n # Paste the forward image on the background image\n imgpaste = cv2.add(img1_bg,img2_fg)\n\n return imgpaste\n\ndef cosineTheorem(Lidar, radian1, radian2):\n theta = abs(radian1-radian2)\n distance = Lidar[radian1][1] ** 2 + Lidar[radian2][1] ** 2 - 2 * Lidar[radian1][1] * Lidar[radian2][1] * math.cos(abs(radian2 - radian1))\n\n return distance\n\ndef combinations_count(n, r):\n return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))\n# def beep(freq, dur=100):\n# winsound.Beep(freq, dur)\n\nif __name__ == '__main__':\n #学習前YOLO\n # cfgfile = \"cfg/yolov3.cfg\" # 設定ファイル\n # weightsfile = \"weight/yolov3.weights\" # 重みファイル\n # classes = load_classes('data/coco.names') # 識別クラスのリスト\n\n #マスク学習後YOLO\n cfgfile = \"cfg/mask.cfg\" # 設定ファイル\n weightsfile = \"weight/mask_1500.weights\" # 重みファイル\n classes = load_classes('data/mask.names') # 識別クラスのリスト\n\n\n num_classes = 80 # クラスの数\n\n args = arg_parse() # 引数を取得\n confidence = float(args.confidence) # 信頼性の設定値を取得\n nms_thesh = float(args.nms_thresh) # 閾値を取得\n start = 0\n CUDA = torch.cuda.is_available() # CUDAが使用可能かどうか\n\n num_classes = 80 # クラスの数\n bbox_attrs = 5 + num_classes\n max = 0 #限界人数\n num_camera = 1 #camera数\n model = [[] for i in range(num_camera)]\n inp_dim = [[] for i in range(num_camera)]\n cap = [[] for i in range(num_camera)]\n ret = [[] for i in range(num_camera)]\n frame = [[] for i in range(num_camera)]\n img = [[] for i in range(num_camera)]\n orig_im = [[] for i in range(num_camera)]\n dim = [[] for i in range(num_camera)]\n # output = [[] for i in range(num_camera)]\n # output = torch.tensor(output)\n # print(\"output_shape\\n\", output.shape)\n\n for i in range(num_camera):\n model[i] = Darknet(cfgfile) #model1の作成\n model[i].load_weights(weightsfile) # model1に重みを読み込む\n\n model[i].net_info[\"height\"] = args.reso\n inp_dim[i] = int(model[i].net_info[\"height\"])\n\n assert inp_dim[i] % 32 == 0\n assert inp_dim[i] > 32\n\n #mixer.init() #初期化\n\n if CUDA:\n for i in range(num_camera):\n model[i].cuda() #CUDAが使用可能であればcudaを起動\n\n for i in range(num_camera):\n model[i].eval()\n\n cap[0] = cv2.VideoCapture(1) #カメラを指定（USB接続）\n # cap[1] = cv2.VideoCapture(1) #カメラを指定（USB接続）\n # cap = cv2.VideoCapture(\"movies/sample.mp4\")\n #cap = cv2.VideoCapture(\"movies/one_v2.avi\")\n\n # Use the next line if your camera has a username and password\n # cap = cv2.VideoCapture('protocol://username:password@IP:port/1')\n #cap = cv2.VideoCapture('rtsp://admin:admin@192.168.11.4/1') #（ネットワーク接続）\n #cap = cv2.VideoCapture('rtsp://admin:admin@192.168.11.4/80')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.4:80/video')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.4/camera-cgi/admin/recorder.cgi?action=start&id=samba')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.4/recorder.cgi?action=start&id=samba')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.5:80/snapshot.jpg?user=admin&pwd=admin&strm=0')\n print('-1')\n\n #assert cap.isOpened(), 'Cannot capture source' #カメラが起動できたか確認\n\n img1 = cv2.imread(\"images/phase_1.jpg\")\n img2 = cv2.imread(\"images/phase_2.jpg\")\n img3 = cv2.imread(\"images/phase_2_red.jpg\")\n img4 = cv2.imread(\"images/phase_3.jpg\")\n #mixer.music.load(\"voice/voice_3.m4a\")\n #print(img1)\n frames = 0\n count_frame = 0 #フレーム数カウント\n flag = 0 #密状態（0：疎密，1：密入り）\n start = time.time()\n print('-1')\n while (cap[i].isOpened() for i in range(num_camera)): #カメラが起動している間\n count=0 #人数をカウント\n point = [[] for i in range(num_camera)]\n for i in range(num_camera):\n ret[i], frame[i] = cap[i].read() #キャプチャ画像を取得\n if (ret[i] for i in range(num_camera)):\n # 解析準備としてキャプチャ画像を加工\n for i in range(num_camera):\n img[i], orig_im[i], dim[i] = prep_image(frame[i], inp_dim[i])\n\n if CUDA:\n for i in range(num_camera):\n im_dim[i] = im_dim[i].cuda()\n img[i] = img[i].cuda()\n\n for i in range(num_camera):\n # output[i] = model[i](Variable(img[i]), CUDA)\n output = model[i](Variable(img[i]), CUDA)\n\n #print(\"output:\\n\", output)\n # output[i] = write_results(output[i], confidence, num_classes, nms = True, nms_conf = nms_thesh)\n output = write_results(output, confidence, num_classes, nms = True, nms_conf = nms_thesh)\n\n # print(\"output\", i, \":\\n\", output[i])\n print(output.shape)\n \"\"\"\n # FPSの表示\n if (type(output[i]) == int for i in range(num_camera)):\n print(\"表示\")\n frames += 1\n print(\"FPS of the video is {:5.2f}\".format( frames / (time.time() - start)))\n\n # qキーを押すとFPS表示の終了\n key = cv2.waitKey(1)\n if key & 0xFF == ord('q'):\n break\n continue\n for i in range(num_camera):\n output[i][:,1:5] = torch.clamp(output[i][:,1:5], 0.0, float(inp_dim[i]))/inp_dim[i]\n output[i][:,[1,3]] *= frame[i].shape[1]\n output[i][:,[2,4]] *= frame[i].shape[0]\n \"\"\"\n # FPSの表示\n if type(output) == int:\n print(\"表示\")\n frames += 1\n print(\"FPS of the video is {:5.2f}\".format( frames / (time.time() - start)))\n\n # qキーを押すとFPS表示の終了\n key = cv2.waitKey(1)\n if key & 0xFF == ord('q'):\n break\n continue\n for i in range(num_camera):\n output[:,1:5] = torch.clamp(output[:,1:5], 0.0, float(inp_dim[i]))/inp_dim[i]\n output[:,[1,3]] *= frame[i].shape[1]\n output[:,[2,4]] *= frame[i].shape[0]\n\n\n\n colors = pkl.load(open(\"pallete\", \"rb\"))\n\n #count = lambda x: count(x, orig_im, count) #人数をカウント\n \"\"\"\n for i in range(num_camera):\n list(map(lambda x: write(x, orig_im[i]), output[i]))\n print(\"count:\\n\",count)\n \"\"\"\n for i in range(num_camera):\n list(map(lambda x: write(x, orig_im[i], i), output))\n print(\"count:\\n\",count)\n print(\"count_frame\", count_frame)\n # print(\"framex\", frame[0].shape[1])\n # print(\"framey\", frame[0].shape[0])\n # print(\"point0\",point[0])\n\n #LiDARの情報の人識別\n radian_lists = []\n close_list = [0] * 4\n dense_list = [0] * 4\n for k, (radian, length) in enumerate(LiDAR_list):\n if not type(length) == type('string'):\n radian_cam = [[] for i in range(len(point))]\n num_person = 0\n # print(\"k:\", k)\n if k % 90 == 0:\n # print(\"hahahah\")\n if not k == 0:\n radian_lists.append(radian_list)\n radian_list = []\n if k < 90:\n for num, p in enumerate(point[0]):\n radian_cam[num] = p[0] / frame[0].shape[1] * 100\n print(\"radian_cam\", radian_cam[0])\n for dif in range(10):\n for radi_num in range(len(radian_cam)):\n if int(radian)+dif-5 == int(radian_cam[radi_num]):\n num_person += 1\n radian_list.append(radian)\n if num_person > 1:\n close_list[0] = 1\n if num_person > 2:\n dense_list[0] = 1\n elif k < 180:\n for num, p in enumerate(point[0]):\n radian_cam[num] = p[0] / frame[0].shape[1] * 100\n for dif in range(10):\n for radi_num in range(len(radian_cam)):\n if int(radian)+dif-5 == int(radian_cam[radi_num]):\n num_person += 1\n radian_list.append(radian)\n if num_person > 1:\n close_list[1] = 1\n if num_person > 2:\n dense_list[1] = 1\n elif k < 270:\n for num, p in enumerate(point[0]):\n radian_cam[num] = p[0] / frame[0].shape[1] * 100\n for dif in range(10):\n for radi_num in range(len(radian_cam)):\n if int(radian)+dif-5 == int(radian_cam[radi_num]):\n num_person += 1\n radian_list.append(radian)\n if num_person > 1:\n close_list[2] = 1\n if num_person > 2:\n dense_list[2] = 1\n else:\n for num, p in enumerate(point[0]):\n radian_cam[num] = p[0] / frame[0].shape[1] * 100\n for dif in range(10):\n for radi_num in range(len(radian_cam)):\n if int(radian)+dif-5 == int(radian_cam[radi_num]):\n num_person += 1\n radian_list.append(radian)\n if num_person > 1:\n close_list[3] = 1\n if num_person > 2:\n dense_list[3] = 1\n radian_lists.append(radian_list)\n # print(\"radian_lists_len\", len(radian_lists))\n\n #距離計算\n dis_list = []\n for direction in range(4):\n if len(radian_lists[direction]) > 1:\n # n = combinations_k(len(radian_lists[direction]), 2)\n dis_combination = list(itertools.combinations(radian_lists[direction], 2))\n distance = [[] for i in range(len(dis_combination))]\n print(type(LiDAR_list[0][0]))\n for num_dis, com_list in enumerate(dis_combination):\n distance[num_dis] = cosineTheorem(LiDAR_list, int(com_list[0]), int(com_list[1]))\n dis_list.append(distance)\n\n #密集判定\n for direction in range(4):\n close = 0 #密接数\n dense = 0 #密集数\n print(type(direction))\n for dis in dis_list[direction]:\n if dis < 2.0:\n close += 1\n close_list[direction] = 1\n if close > 1:\n dense_list[direction] = 1\n\n print(\"close_list\", close_list)\n print(\"dense_list\", dense_list)\n\n # print(\"point1\",point[1])\n\n\n if count > max:\n count_frame += 1\n #print(\"-1\")\n if count_frame <= 50:\n x=0\n y=0\n angle=20\n scale=1.5\n for i in range(num_camera):\n imgpaste = cvpaste(img1, orig_im[i], x, y, angle, scale)\n if flag == 1:\n play.googlehome()\n flag += 1\n #mixer.music.play(1)\n elif count_frame <= 100:\n x=-30\n y=10\n angle=20\n scale=1.1\n if count_frame%2==1:\n for i in range(num_camera):\n imgpaste = cvpaste(img2, orig_im[i], x, y, angle, scale)\n else:\n for i in range(num_camera):\n imgpaste = cvpaste(img3, orig_im[i], x, y, angle, scale)\n if flag == 2:\n play.googlehome()\n flag += 1\n else:\n x=-30\n y=0\n angle=20\n scale=1.5\n for i in range(num_camera):\n imgpaste = cvpaste(img4, orig_im[i], x, y, angle, scale)\n if count_frame > 101: #<--2フレームずらす\n print(\"\\007\") #警告音\n time.sleep(3)\n if flag == 3:\n play.googlehome()\n flag += 1\n cv2.imshow(\"frame\", imgpaste)\n else:\n count_frame = 0\n flag = 0\n #print(\"-2\")\n for i in range(num_camera):\n cv2.imshow(\"frame\", orig_im[i])\n # play.googlehome()\n key = cv2.waitKey(1)\n # qキーを押すと動画表示の終了\n if key & 0xFF == ord('q'):\n break\n frames += 1\n print(\"count_frame:\\n\", count_frame)\n print(\"FPS of the video is {:5.2f}\".format( frames / (time.time() - start)))\n\n else:\n break\n\n",
"from __future__ import division\nimport time\nimport torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\nimport numpy as np\nimport cv2\nfrom util import *\nfrom darknet import Darknet\nfrom preprocess import prep_image, inp_to_image\nimport pandas as pd\nimport random\nimport argparse\nimport pickle as pkl\n\nimport requests\nfrom requests.auth import HTTPDigestAuth\n\nimport io\nfrom PIL import Image, ImageDraw, ImageFilter\n\nimport play\n\n#from pygame import mixer\n#import winsound\n\ncamera_name = {\n \"north\":0,\n \"south\":2,\n \"east\":1,\n \"west\":3,\n}\n\ndef prep_image(img, inp_dim):\n # CNNに通すために画像を加工する\n orig_im = img\n dim = orig_im.shape[1], orig_im.shape[0]\n img = cv2.resize(orig_im, (inp_dim, inp_dim))\n img_ = img[:,:,::-1].transpose((2,0,1)).copy()\n img_ = torch.from_numpy(img_).float().div(255.0).unsqueeze(0)\n return img_, orig_im, dim\n\ndef count(x, img, count):\n # 画像に結果を描画\n c1 = tuple(x[1:3].int())\n c2 = tuple(x[3:5].int())\n cls = int(x[-1])\n label = \"{0}\".format(classes[cls])\n print(\"label:\\n\", label)\n # 人数カウント\n if(label=='no-mask'):\n count+=1\n print(count)\n\n return count\n\ndef write(x, img):\n global count\n global point\n p = [0,0]\n # 画像に結果を描画\n print(\"x:\\n\", x)\n c1 = tuple(x[1:3].int())\n c2 = tuple(x[3:5].int())\n cls = int(x[-1])\n label = \"{0}\".format(classes[cls])\n print(\"label:\", label)\n # 人数カウント\n if(label=='no-mask'):\n count+=1\n print(count)\n\n color = random.choice(colors)\n cv2.rectangle(img, c1, c2,color, 1)\n t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_PLAIN, 1 , 1)[0]\n c2 = c1[0] + t_size[0] + 3, c1[1] + t_size[1] + 4\n cv2.rectangle(img, c1, c2,color, -1)\n cv2.putText(img, label, (c1[0], c1[1] + t_size[1] + 4), cv2.FONT_HERSHEY_PLAIN, 1, [225,255,255], 1);\n p[0] = (c1[0]-c2[0])/2\n p[1] = (c1[1]-c2[1])/2\n point[camId].append(p)\n return img\n\ndef arg_parse():\n # モジュールの引数を作成\n parser = argparse.ArgumentParser(description='YOLO v3 Cam Demo') # ArgumentParserで引数を設定する\n parser.add_argument(\"--confidence\", dest = \"confidence\", help = \"Object Confidence to filter predictions\", default = 0.25)\n # confidenceは信頼性\n parser.add_argument(\"--nms_thresh\", dest = \"nms_thresh\", help = \"NMS Threshhold\", default = 0.4)\n # nms_threshは閾値\n\n parser.add_argument(\"--reso\", dest = 'reso', help =\n \"Input resolution of the network. Increase to increase accuracy. Decrease to increase speed\",\n default = \"160\", type = str)\n # resoはCNNの入力解像度で、増加させると精度が上がるが、速度が低下する。\n return parser.parse_args() # 引数を解析し、返す\n\ndef cvpaste(img, imgback, x, y, angle, scale):\n # x and y are the distance from the center of the background image\n\n r = img.shape[0]\n c = img.shape[1]\n rb = imgback.shape[0]\n cb = imgback.shape[1]\n hrb=round(rb/2)\n hcb=round(cb/2)\n hr=round(r/2)\n hc=round(c/2)\n\n # Copy the forward image and move to the center of the background image\n imgrot = np.zeros((rb,cb,3),np.uint8)\n imgrot[hrb-hr:hrb+hr,hcb-hc:hcb+hc,:] = img[:hr*2,:hc*2,:]\n\n # Rotation and scaling\n M = cv2.getRotationMatrix2D((hcb,hrb),angle,scale)\n imgrot = cv2.warpAffine(imgrot,M,(cb,rb))\n # Translation\n M = np.float32([[1,0,x],[0,1,y]])\n imgrot = cv2.warpAffine(imgrot,M,(cb,rb))\n\n # Makeing mask\n imggray = cv2.cvtColor(imgrot,cv2.COLOR_BGR2GRAY)\n ret, mask = cv2.threshold(imggray, 10, 255, cv2.THRESH_BINARY)\n mask_inv = cv2.bitwise_not(mask)\n\n # Now black-out the area of the forward image in the background image\n img1_bg = cv2.bitwise_and(imgback,imgback,mask = mask_inv)\n\n # Take only region of the forward image.\n img2_fg = cv2.bitwise_and(imgrot,imgrot,mask = mask)\n\n # Paste the forward image on the background image\n imgpaste = cv2.add(img1_bg,img2_fg)\n\n return imgpaste\n\ndef hconcat_resize_min(im_list, interpolation=cv2.INTER_CUBIC):\n h_min = min(im.shape[0] for im in im_list)\n im_list_resize = [cv2.resize(im, (int(im.shape[1] * h_min / im.shape[0]), h_min), interpolation=interpolation)\n for im in im_list]\n return cv2.hconcat(im_list_resize)\n\n# def beep(freq, dur=100):\n# winsound.Beep(freq, dur)\n\nif __name__ == '__main__':\n #学習前YOLO\n # cfgfile = \"cfg/yolov3.cfg\" # 設定ファイル\n # weightsfile = \"weight/yolov3.weights\" # 重みファイル\n # classes = load_classes('data/coco.names') # 識別クラスのリスト\n\n #マスク学習後YOLO\n cfgfile = \"cfg/mask.cfg\" # 設定ファイル\n weightsfile = \"weight/mask_1500.weights\" # 重みファイル\n classes = load_classes('data/mask.names') # 識別クラスのリスト\n\n\n num_classes = 80 # クラスの数\n\n args = arg_parse() # 引数を取得\n confidence = float(args.confidence) # 信頼性の設定値を取得\n nms_thesh = float(args.nms_thresh) # 閾値を取得\n start = 0\n CUDA = torch.cuda.is_available() # CUDAが使用可能かどうか\n\n num_classes = 80 # クラスの数\n bbox_attrs = 5 + num_classes\n max = 2 #限界人数\n\n #-------適宜変更------------------------------------\n num_camera = 3 #camera数\n #-------適宜変更------------------------------------\n\n\n # cap = [[] for i in range(num_camera)]\n\n #-------適宜変更------------------------------------\n cap[0] = cv2.VideoCapture(0) #カメラを指定（ivcam)\n cap[1] = cv2.VideoCapture(1) #カメラを指定（native）\n # cap[2] = cv2.VideoCapture(2) #カメラを指定（USB接続）\n # cap[3] = cv2.VideoCapture(3) #カメラを指定（USB接続）\n # cap = cv2.VideoCapture(\"movies/sample.mp4\")\n #cap = cv2.VideoCapture(\"movies/one_v2.avi\")\n #-------適宜変更------------------------------------\n\n for i in range(num_camera):\n if not cap[i].isOpened():\n if i < num_camera - 1:\n for j in range(len(num_camera - i) - 1):\n cap[i + j] = cap[i + j + 1]\n cap.pop()\n num_camera -= 1\n\n # Use the next line if your camera has a username and password\n # cap = cv2.VideoCapture('protocol://username:password@IP:port/1')\n #cap = cv2.VideoCapture('rtsp://admin:admin@192.168.11.4/1') #（ネットワーク接続）\n #cap = cv2.VideoCapture('rtsp://admin:admin@192.168.11.4/80')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.4:80/video')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.4/camera-cgi/admin/recorder.cgi?action=start&id=samba')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.4/recorder.cgi?action=start&id=samba')\n #cap = cv2.VideoCapture('http://admin:admin@192.168.11.5:80/snapshot.jpg?user=admin&pwd=admin&strm=0')\n print('-1')\n\n model = [[] for i in range(num_camera)]\n inp_dim = [[] for i in range(num_camera)]\n ret = [[] for i in range(num_camera)]\n frame = [[] for i in range(num_camera)]\n img = [[] for i in range(num_camera)]\n orig_im = [[] for i in range(num_camera)]\n dim = [[] for i in range(num_camera)]\n output0 = []\n output1 = []\n output2 = []\n output3 = []\n\n for i in range(num_camera):\n model[i] = Darknet(cfgfile) #model1の作成\n model[i].load_weights(weightsfile) # model1に重みを読み込む\n\n model[i].net_info[\"height\"] = args.reso\n inp_dim[i] = int(model[i].net_info[\"height\"])\n\n assert inp_dim[i] % 32 == 0\n assert inp_dim[i] > 32\n\n #mixer.init() #初期化\n\n if CUDA:\n for i in range(num_camera):\n model[i].cuda() #CUDAが使用可能であればcudaを起動\n\n for i in range(num_camera):\n model[i].eval()\n\n #assert cap.isOpened(), 'Cannot capture source' #カメラが起動できたか確認\n\n img1 = cv2.imread(\"images/phase_1.jpg\")\n img2 = cv2.imread(\"images/phase_2.jpg\")\n img3 = cv2.imread(\"images/phase_2_red.jpg\")\n img4 = cv2.imread(\"images/phase_3.jpg\")\n\n frames = 0\n count_frame = 0 #フレーム数カウント\n flag = 0 #密状態（0：疎密，1：密入り）\n start = time.time()\n print('-1')\n print(\"num_camera\", num_camera)\n while (cap[i].isOpened() for i in range(num_camera)): #カメラが起動している間\n print(\"len_cap\", len(cap))\n count=0 #人数をカウント\n point = [[] for i in range(num_camera)]\n for i in range(num_camera):\n ret[i], frame[i] = cap[i].read() #キャプチャ画像を取得\n if (ret[i] for i in range(num_camera)):\n # 解析準備としてキャプチャ画像を加工\n for i in range(num_camera):\n img[i], orig_im[i], dim[i] = prep_image(frame[i], inp_dim[i])\n\n if CUDA:\n for i in range(num_camera):\n im_dim[i] = im_dim[i].cuda()\n img[i] = img[i].cuda()\n\n \"\"\"\n output = []\n for i in range(num_camera):\n output.append(model[i](Variable(img[i]), CUDA))\n print(\"output\\n\", output)\n # print(\"output\", i, \"\\n\", output[i])\n output[i] = write_results(output[i], confidence, num_classes, nms = True, nms_conf = nms_thesh)\n # print(\"output\\n\", output)\n \"\"\"\n output0 = model[i](Variable(img[i]), CUDA)\n output1 = model[i](Variable(img[i]), CUDA)\n # output2 = model[i](Variable(img[i]), CUDA)\n # output3 = model[i](Variable(img[i]), CUDA)\n\n #print(\"output:\\n\", output)\n # output[i] = write_results(output[i], confidence, num_classes, nms = True, nms_conf = nms_thesh)\n output0 = write_results(output0, confidence, num_classes, nms = True, nms_conf = nms_thesh)\n output1 = write_results(output1, confidence, num_classes, nms = True, nms_conf = nms_thesh)\n\n # print(\"output\", i, \":\\n\", output[i])\n # print(output.shape)\n\n \"\"\"\n # FPSの表示\n if type(output) == int:#type(output0) == int or type(output1) == int or type(output2) == int\n # print(type(output))\n print(\"表示\")\n frames += 1\n print(\"FPS of the video is {:5.2f}\".format( frames / (time.time() - start)))\n\n # qキーを押すとFPS表示の終了\n key = cv2.waitKey(1)\n if key & 0xFF == ord('q'):\n break\n continue\n \"\"\"\n \"\"\"\n # FPSの表示\n if (type(output[i]) == int for i in range(num_camera)):#type(output0) == int or type(output1) == int or type(output2) == int\n # print(type(output))\n print(\"表示\")\n frames += 1\n print(\"FPS of the video is {:5.2f}\".format( frames / (time.time() - start)))\n\n # qキーを押すとFPS表示の終了\n key = cv2.waitKey(1)\n if key & 0xFF == ord('q'):\n break\n continue\n \"\"\"\n\n\n \"\"\"\n for i in range(num_camera):\n print(\"len_output\", len(output))\n print(\"len_output[]\", len(output[0]))\n print(\"len_output[][]\", len(output[0][0]))\n if i == 0:\n output[:1, :,1:5] = torch.clamp(output[:1, :,1:5], 0.0, float(inp_dim[i]) ) / inp_dim[i]\n output[:1, :,[1,3]] *= frame[0].shape[1]\n output[:1, :,[2,4]] *= frame[0].shape[0]\n elif i == num_classes - 1:\n output[i:, :,1:5] = torch.clamp(output[i:, :,1:5], 0.0, float(inp_dim[i]) ) / inp_dim[i]\n output[i:, :,[1,3]] *= frame[0].shape[1]\n output[i:, :,[2,4]] *= frame[0].shape[0]\n else:\n output[i:i+1, :,1:5] = torch.clamp(output[i:i+1, :,1:5], 0.0, float(inp_dim[i]) ) / inp_dim[i]\n output[i:i+1, :,[1,3]] *= frame[0].shape[1]\n output[i:i+1, :,[2,4]] *= frame[0].shape[0]\n \"\"\"\n output0[:,1:5] = torch.clamp(output0[:,1:5], 0.0, float(inp_dim[i]))/inp_dim[i]\n output0[:,[1,3]] *= frame[i].shape[1]\n output0[:,[2,4]] *= frame[i].shape[0]\n\n output1[:,1:5] = torch.clamp(output1[:,1:5], 0.0, float(inp_dim[i]))/inp_dim[i]\n output1[:,[1,3]] *= frame[i].shape[1]\n output1[:,[2,4]] *= frame[i].shape[0]\n\n colors = pkl.load(open(\"pallete\", \"rb\"))\n\n #count = lambda x: count(x, orig_im, count) #人数をカウント\n \"\"\"\n for i in range(num_camera):\n list(map(lambda x: write(x, orig_im[i]), output[i]))\n \"\"\"\n\n list(map(lambda x0: write(x0, orig_im[0],0), output0))\n list(map(lambda x1: write(x1, orig_im[1],1), output1))\n # print(\"x0\",x0)\n # list(map(lambda x2: write(x2, orig_im[2],2), output2))\n # list(map(lambda x3: write(x3, orig_im[3],3), output3))\n print(\"point0\",point[0])\n print(\"point1\",point[1])\n print(\"count:\\n\",count)\n\n\n if count > max:\n count_frame += 1\n #print(\"-1\")\n if count_frame <= 50:\n x=0\n y=0\n angle=20\n scale=1.5\n for i in range(num_camera):\n imgpaste = cvpaste(img1, orig_im[i], x, y, angle, scale)\n if flag == 1:\n play.googlehome()\n flag += 1\n #mixer.music.play(1)\n # 2000Hzで500ms秒鳴らす\n #beep(2000, 500)\n elif count_frame <= 100:\n x=-30\n y=10\n angle=20\n scale=1.1\n if count_frame%2==1:\n for i in range(num_camera):\n imgpaste = cvpaste(img2, orig_im[i], x, y, angle, scale)\n else:\n for i in range(num_camera):\n imgpaste = cvpaste(img3, orig_im[i], x, y, angle, scale)\n if flag == 2:\n play.googlehome()\n flag += 1\n else:\n x=-30\n y=0\n angle=20\n scale=1.5\n for i in range(num_camera):\n imgpaste = cvpaste(img4, orig_im[i], x, y, angle, scale)\n if count_frame > 101: #<--2フレームずらす\n print(\"\\007\") #警告音\n time.sleep(3)\n if flag == 3:\n play.googlehome()\n flag += 1\n cv2.imshow(\"frame\", imgpaste)\n else:\n count_frame = 0\n #print(\"-2\")\n for i in range(num_camera):\n # print(\"orig_im\\n\", orig_im)\n # print(\"len_orim_im\", len(orig_im))\n im_h_resize = hconcat_resize_min(orig_im)\n cv2.imshow(\"frame\", im_h_resize)\n key = cv2.waitKey(1)\n # qキーを押すと動画表示の終了\n if key & 0xFF == ord('q'):\n break\n frames += 1\n print(\"count_frame:\\n\", count_frame)\n print(\"FPS of the video is {:5.2f}\".format( frames / (time.time() - start)))\n\n else:\n break\n\n"
] |
[
[
"numpy.zeros",
"torch.autograd.Variable",
"torch.from_numpy",
"numpy.float32",
"torch.cuda.is_available"
],
[
"numpy.array",
"numpy.zeros",
"torch.autograd.Variable",
"numpy.split",
"torch.from_numpy",
"numpy.float32",
"torch.cuda.is_available",
"numpy.append"
],
[
"numpy.zeros",
"torch.autograd.Variable",
"torch.from_numpy",
"numpy.float32",
"torch.cuda.is_available"
]
] |
XHChen0528/Pytorch-Project-Template
|
[
"3615fd90eb5ae2eb098b591204f1da087ab1179b"
] |
[
"related_scripts/test_dataloader_hdf5.py"
] |
[
"#!/usr/bin/env python3\n# -*- coding:utf-8 -*-\n#############################################################\n# File: test_dataloader_hdf5.py.py\n# Created Date: Tuesday January 12th 2021\n# Author: Chen Xuanhong\n# Email: chenxuanhongzju@outlook.com\n# Last Modified: Wednesday, 13th January 2021 10:39:00 am\n# Modified By: Chen Xuanhong\n# Copyright (c) 2021 Shanghai Jiao Tong University\n#############################################################\n\nimport os\nimport glob\nimport h5py\nimport torch\nimport random\n\nfrom pathlib import Path\n\n\nclass TestDataset:\n def __init__(self, \n h5_path,\n batch_size=16):\n \"\"\"Initialize and preprocess the CelebA dataset.\"\"\"\n self.batch_size = batch_size\n self.pointer = 0\n\n self.h5_path= h5_path\n self.h5file = h5py.File(h5_path,'r')\n self.keys = self.h5file[\"__len__\"][()] #86366\n self.length = self.keys\n self.keys = [str(k) for k in range(self.keys)]\n\n def __call__(self):\n \"\"\"Return one batch images.\"\"\"\n \n # if self.pointer>=self.length:\n # self.pointer = 0\n\n if self.pointer>=self.length:\n self.pointer = 0\n a = \"The end of the story!\"\n raise StopIteration(print(a))\n elif (self.pointer+self.batch_size) > self.length:\n end = self.length\n else:\n end = self.pointer+self.batch_size\n for i in range(self.pointer, end):\n iii = self.keys[i]\n hr = torch.from_numpy(self.h5file[iii+\"hr\"][()])\n lr = torch.from_numpy(self.h5file[iii+\"lr\"][()])\n \n if (i-self.pointer) == 0:\n hr_ls = hr.unsqueeze(0)\n lr_ls = lr.unsqueeze(0)\n else:\n hr_ls = torch.cat((hr_ls,hr.unsqueeze(0)),0)\n lr_ls = torch.cat((lr_ls,lr.unsqueeze(0)),0)\n self.pointer = end\n return lr_ls, hr_ls\n \n def __len__(self):\n return self.length\n\n def __repr__(self):\n return self.__class__.__name__ + ' (' + self.h5_path + ')'\n\nif __name__ == \"__main__\":\n \n dataset_path = \"G:\\\\RainNet\\\\RainNet_H5\\\\RainNet_Evaluation.hdf5\"\n\n hdf5_dataloader = TestDataset(dataset_path,64)\n print(len(hdf5_dataloader))\n # hdf5_dataloader = iter(hdf5_dataloader)\n import time\n import datetime\n start_time = time.time()\n for i in range(100):\n lr,hr = hdf5_dataloader()\n # lr,hr = next(hdf5_dataloader)\n print(hr.shape)\n # hr = hr +1\n elapsed = time.time() - start_time\n elapsed = str(datetime.timedelta(seconds=elapsed))\n print(\"Elapsed [{}]\".format(elapsed))"
] |
[
[
"torch.from_numpy"
]
] |
B-DE/ChatbotMachine
|
[
"ec5668411c037fe1f0b265f21114b944dc9ba169"
] |
[
"kochat/utils/visualizer.py"
] |
[
"\"\"\"\n@auther Hyunwoong\n@since {6/23/2020}\n@see : https://github.com/gusdnd852\n\"\"\"\nimport itertools\nimport os\nimport re\n\nimport numpy as np\nimport pandas as pd\nimport six\nfrom matplotlib import pyplot as plt\nfrom pandas import DataFrame\nfrom sklearn.decomposition import IncrementalPCA\nfrom torch import Tensor\n\nfrom kochat.decorators import backend\n\n\n# gui 오류에 대한 코드\nimport matplotlib\nmatplotlib.use('Agg')\nfrom matplotlib import pyplot as plt\n\n\n@backend\nclass Visualizer:\n\n def __init__(self, model_dir: str, model_file: str):\n \"\"\"\n 학습, 검증 결과를 저장하고 시각화하는 클래스입니다.\n \"\"\"\n\n if not os.path.exists(model_dir):\n os.makedirs(model_dir)\n\n if not os.path.exists(model_dir + 'temp'):\n os.makedirs(model_dir + 'temp')\n\n self.model_dir = model_dir\n self.model_file = model_file\n self.train_loss, self.test_loss = [], []\n self.train_accuracy, self.test_accuracy = [], []\n self.train_precision, self.test_precision = [], []\n self.train_recall, self.test_recall = [], []\n self.train_f1_score, self.test_f1_score = [], []\n\n def save_result(self, loss: Tensor, eval_dict: dict, mode: str):\n \"\"\"\n training / test 결과를 저장합니다.\n\n :param loss: loss 리스트\n :param eval_dict: 다양한 메트릭으로 평가한 결과가 저장된 딕셔너리\n :param mode: train or test\n \"\"\"\n if mode == 'train':\n self.train_loss.append(loss.item())\n self.train_accuracy.append(eval_dict['accuracy'].item())\n self.train_precision.append(eval_dict['precision'].item())\n self.train_recall.append(eval_dict['recall'].item())\n self.train_f1_score.append(eval_dict['f1_score'].item())\n self.__save_txt(self.train_accuracy, 'train_accuracy')\n self.__save_txt(self.train_precision, 'train_precision')\n self.__save_txt(self.train_recall, 'train_recall')\n self.__save_txt(self.train_f1_score, 'train_f1_score')\n self.__save_txt(self.train_loss, 'train_loss')\n\n elif mode == 'test':\n self.test_loss.append(loss.item())\n self.test_accuracy.append(eval_dict['accuracy'].item())\n self.test_precision.append(eval_dict['precision'].item())\n self.test_recall.append(eval_dict['recall'].item())\n self.test_f1_score.append(eval_dict['f1_score'].item())\n self.__save_txt(self.test_accuracy, 'test_accuracy')\n self.__save_txt(self.test_precision, 'test_precision')\n self.__save_txt(self.test_recall, 'test_recall')\n self.__save_txt(self.test_f1_score, 'test_f1_score')\n self.__save_txt(self.test_loss, 'test_loss')\n\n else:\n raise Exception('mode는 train과 test만 가능합니다.')\n\n def draw_graphs(self):\n \"\"\"\n 다양한 메트릭 그래프를 그립니다.\n test가 True인 경우 testing 결과도 함께 그립니다.\n \"\"\"\n\n plt.plot(self.__load_txt('train_accuracy'), 'darkgreen', label='train_accuracy')\n if len(self.test_accuracy) != 0:\n plt.plot(self.__load_txt('test_accuracy'), 'limegreen', label='test_accuracy')\n self.__draw_graph('accuracy')\n\n plt.plot(self.__load_txt('train_precision'), 'darkcyan', label='train_precision')\n if len(self.test_precision) != 0:\n plt.plot(self.__load_txt('test_precision'), 'cyan', label='test_precision')\n self.__draw_graph('precision')\n\n plt.plot(self.__load_txt('train_recall'), 'darkred', label='train_recall')\n if len(self.test_recall) != 0:\n plt.plot(self.__load_txt('test_recall'), 'red', label='test_recall')\n self.__draw_graph('recall')\n\n plt.plot(self.__load_txt('train_f1_score'), 'darkmagenta', label='train_f1_score')\n if len(self.test_f1_score) != 0:\n plt.plot(self.__load_txt('test_f1_score'), 'magenta', label='test_f1_score')\n self.__draw_graph('f1_score')\n\n plt.plot(self.__load_txt('train_loss'), 'darkgoldenrod', label='train_loss')\n if len(self.test_loss) != 0:\n plt.plot(self.__load_txt('test_loss'), 'gold', label='test_loss')\n self.__draw_graph('loss')\n\n def draw_matrix(self, cm: np.ndarray, target_names: list, mode: str):\n \"\"\"\n metrics에서 출력된 confusion matrix을 시각화해서 그리고 저장합니다.\n\n :param cm: confusion matrix 객체\n :param target_names: 각 클래스들의 이름\n :param mode: train or test 모드\n \"\"\"\n\n label_length = len(target_names)\n figure_base_size = (label_length * 1.5)\n title_font_size = (label_length * 3) + 7\n\n cmap = plt.get_cmap('Blues')\n cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n\n plt.figure(figsize=(figure_base_size + 7, figure_base_size + 4))\n im = plt.imshow(cm, interpolation='nearest', cmap=cmap)\n plt.title(\n label='{} confusion matrix'.format(mode),\n fontdict={'fontsize': title_font_size},\n pad=35\n )\n\n tick_marks = np.arange(label_length)\n plt.xticks(tick_marks, target_names)\n plt.yticks(tick_marks, target_names)\n plt.colorbar(im, fraction=0.046, pad=0.04)\n thresh = cm.max() / 1.5\n\n for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n plt.text(j, i, \"{:0.4f}\".format(cm[i, j]),\n horizontalalignment=\"center\",\n color=\"white\" if cm[i, j] > thresh else \"black\")\n\n plt.tight_layout()\n plt.savefig(self.model_file + '_confusion_matrix_{}.png'.format(mode))\n plt.close()\n\n def draw_report(self, report: DataFrame, mode: str):\n \"\"\"\n metrics에서 출력된 classification report를 시각화해서 그리고 저장합니다.\n\n :param report: report 데이터 프래임\n :param mode: train or test 모드\n \"\"\"\n row_colors = ['#f0f0f0', 'w']\n col_width, row_height, header_columns = 3.0, 0.625, 0\n\n size = (np.array(report.shape[::-1]) + np.array([0, 1])) * np.array([col_width, row_height])\n fig, ax = plt.subplots(figsize=size)\n ax.axis('off')\n\n table = ax.table(cellText=report.values,\n bbox=[0, 0, 1, 1],\n colLabels=report.columns,\n rowLabels=report.index)\n\n table.auto_set_font_size(False)\n table.set_fontsize(12)\n\n for k, cell in six.iteritems(table._cells):\n cell.set_edgecolor('white')\n if k[0] == 0 or k[1] < header_columns:\n cell.set_text_props(weight='bold', color='w')\n cell.set_facecolor('#09539d')\n else:\n cell.set_facecolor(row_colors[k[0] % len(row_colors)])\n\n fig = ax.get_figure()\n fig.savefig(self.model_file + '_report_{}.png'.format(mode))\n plt.close()\n\n def draw_feature_space(self, feats: Tensor, labels: Tensor, label_dict: dict, loss_name: str,\n d_loss: int, epoch: int, mode: str):\n \"\"\"\n 모든 데이터의 샘플들의 분포를 시각화합니다.\n\n :param feats: 모델의 출력 features\n :param labels: 라벨 리스트\n :param label_dict: 라벨 딕셔너리\n :param loss_name: loss 함수의 이름\n :param d_loss: loss 시각화 차원\n :param epoch: 현재 진행된 epochs\n :param mode: train or test\n \"\"\"\n\n if not isinstance(labels, np.ndarray):\n labels = labels.detach().cpu().numpy()\n if not isinstance(feats, np.ndarray):\n feats = feats.detach().cpu().numpy()\n\n if d_loss == 2:\n self.__2d_feature_space(feats, labels, label_dict)\n else:\n self.__3d_feature_space(feats, labels, label_dict, d_loss)\n\n if not os.path.exists(self.model_dir + 'feature_space'):\n os.makedirs(self.model_dir + 'feature_space')\n\n plt.legend(loc='upper right')\n plt.savefig(self.model_dir +\n 'feature_space/{loss_name}_{d_loss}D_{mode}_{epoch}.png'\n .format(loss_name=loss_name, d_loss=d_loss, mode=mode, epoch=epoch))\n\n plt.close()\n\n def __draw_graph(self, mode: str):\n \"\"\"\n plot된 정보들을 바탕으로 그래프를 그리고 저장합니다.\n\n :param mode: train or test\n \"\"\"\n\n plt.xlabel('epochs')\n plt.ylabel(mode)\n plt.title('train test {}'.format(mode))\n plt.grid(True, which='both', axis='both')\n plt.legend()\n plt.savefig(self.model_file + '_graph_{}.png'.format(mode))\n plt.close()\n\n def __2d_feature_space(self, feats: np.ndarray, labels: np.ndarray, label_dict: dict):\n \"\"\"\n d_loss가 2차원인 경우 2D로 시각화 합니다.\n\n :param feats: 모델의 출력 features\n :param labels: 라벨 리스트\n :param label_dict: 라벨 딕셔너리\n \"\"\"\n\n data = pd.DataFrame(np.c_[feats, labels], columns=['x', 'y', 'label'])\n ax = plt.figure().add_subplot()\n for group in data.groupby('label'):\n group_index, group_table = group\n ax.scatter(group_table['x'], group_table['y'],\n marker='o',\n label=list(label_dict)[int(group_index)])\n\n def __3d_feature_space(self, feats: np.ndarray, labels: np.ndarray, label_dict: dict, d_loss: int):\n \"\"\"\n d_loss가 3차원 이상인 경우 3D로 시각화 합니다.\n\n :param feats: 모델의 출력 features\n :param labels: 라벨 리스트\n :param label_dict: 라벨 딕셔너리\n :param d_loss: loss 시각화 차원\n \"\"\"\n\n if d_loss != 3:\n # 3차원 이상이면 PCA 수행해서 3차원으로 만듬\n pca = IncrementalPCA(n_components=3)\n split_size = (feats.shape[0] // self.batch_size) + 1\n for batch_x in np.array_split(feats, split_size):\n pca.partial_fit(batch_x)\n feats = pca.transform(feats)\n\n ax = plt.figure().gca(projection='3d')\n data = pd.DataFrame(np.c_[feats, labels], columns=['x', 'y', 'z', 'label'])\n for group in data.groupby('label'):\n group_index, group_table = group\n ax.scatter(group_table['x'], group_table['y'], group_table['z'],\n marker='o',\n label=list(label_dict)[int(group_index)])\n\n def __load_txt(self, mode: str):\n \"\"\"\n 저장된 파일을 로드하여 배열로 반환합니다.\n\n :param mode: train or test\n \"\"\"\n\n f = open(self.model_dir + 'temp{_}{mode}.txt'.format(_=self.delimeter, mode=mode), 'r')\n file = f.read()\n file = re.sub('\\\\[', '', file)\n file = re.sub('\\\\]', '', file)\n f.close()\n\n return [float(i) for idx, i in enumerate(file.split(','))]\n\n def __save_txt(self, array: list, mode: str):\n \"\"\"\n 배열을 입력받아서 string 변환해 txt파일로 저장합니다.\n\n :param array: 저장할 배열\n :param mode: train or test\n \"\"\"\n\n f = open(self.model_dir + 'temp{_}{mode}.txt'.format(_=self.delimeter, mode=mode), 'w')\n f.write(str(array))\n f.close()\n"
] |
[
[
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.colorbar",
"pandas.DataFrame",
"matplotlib.pyplot.get_cmap",
"matplotlib.pyplot.subplots",
"numpy.arange",
"matplotlib.pyplot.tight_layout",
"sklearn.decomposition.IncrementalPCA",
"matplotlib.use",
"numpy.array",
"matplotlib.pyplot.close",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.figure",
"numpy.array_split",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.imshow"
]
] |
thirono/basil
|
[
"99052482d9334dd1f5598eb2d2fb4d5399a32291"
] |
[
"basil/HL/sitcp_fifo.py"
] |
[
"#\n# ------------------------------------------------------------\n# Copyright (c) All rights reserved\n# SiLab, Institute of Physics, University of Bonn\n# ------------------------------------------------------------\n#\nimport struct\nimport array\n\nimport numpy as np\n\nfrom basil.HL.HardwareLayer import HardwareLayer\n\n\nclass sitcp_fifo(HardwareLayer):\n ''' SiTCP driver that mimics the RegisterHardwareLayer BRAM and SRAM FIFO interfaces.\n\n No firmware module is available for this driver.\n This is just a driver that replaces BRAM and SRAM FIFO when the SiTCP transfer layer is used.\n '''\n _version = 0\n\n def __getitem__(self, name):\n if name == \"RESET\":\n self._intf.reset() # returns None\n elif name == 'VERSION':\n return self._version\n elif name == 'FIFO_SIZE':\n return self._intf._get_tcp_data_size()\n else:\n super(sitcp_fifo, self).__getitem__(name)\n\n def __setitem__(self, name, value):\n if name == \"RESET\":\n self._intf.reset()\n else:\n super(sitcp_fifo, self).__setitem__(name, value)\n\n def __getattr__(self, name):\n '''called only on last resort if there are no attributes in the instance that match the name\n '''\n if name.isupper():\n return self[name]\n else:\n def method(*args, **kwargs):\n nsplit = name.split('_', 1)\n if len(nsplit) == 2 and nsplit[0] == 'set' and nsplit[1].isupper() and len(args) == 1 and not kwargs:\n self[nsplit[1]] = args[0] # returns None\n elif len(nsplit) == 2 and nsplit[0] == 'get' and nsplit[1].isupper() and not args and not kwargs:\n return self[nsplit[1]]\n else:\n raise AttributeError(\"%r object has no attribute %r\" % (self.__class__, name))\n return method\n\n def __setattr__(self, name, value):\n if name.isupper():\n self[name] = value\n else:\n super(sitcp_fifo, self).__setattr__(name, value)\n\n def get_data(self):\n ''' Reading data from SiTCP FIFO (via TCP).\n\n Returns\n -------\n array : numpy.ndarray\n Array of unsigned integers (32 bit).\n '''\n fifo_size = self._intf._get_tcp_data_size()\n fifo_int_size = int((fifo_size - (fifo_size % 4)) / 4)\n data = self._intf._get_tcp_data(fifo_int_size * 4)\n return np.frombuffer(data, dtype=np.dtype('<u4'))\n\n def set_data(self, data):\n ''' Sending data to via TCP.\n\n Parameters\n ----------\n data : array\n Array of unsigned integers (32 bit).\n '''\n data = array.array('B', struct.unpack(\"{}B\".format(len(data) * 4), struct.pack(\"{}I\".format(len(data)), *data)))\n self._intf._send_tcp_data(data)\n"
] |
[
[
"numpy.dtype"
]
] |
glennhickey/CharlieSandbox
|
[
"2949f8357433a6219abf192f899ab50e2c8edaba",
"2949f8357433a6219abf192f899ab50e2c8edaba"
] |
[
"brca_exchange_cooccurrence_analysis/extract_roh_regions_stats.py",
"brca_exchange_cooccurrence_analysis/extract_roh_region_distributions.plot.py"
] |
[
"import matplotlib\nmatplotlib.use('Agg')\nimport vcf, argparse, sys\nimport numpy as np\nimport pandas as pd\nimport math\nfrom scipy.stats import chisquare\nfrom collections import defaultdict\nimport matplotlib.pyplot\nimport ast\n\ndef parse_args():\n \"\"\" \n Description:\n function 'parse_args' parses arguments from command-line and returns an argparse\n object containing the arguments and their values. Default values are 'False' if option\n is not listed in the command, else the option value is set to True.\n \"\"\"\n parser = argparse.ArgumentParser('Input bcftools roh tab-delimited file and output roh report and histogram.')\n parser.add_argument('-i', '--inROH', type=str,\n help='Input bcftools roh output filepath.')\n parser.add_argument('-o', '--outReport', type=str,\n help='Output report filename.')\n\n options = parser.parse_args()\n return options\n\n# Shamelessly pulled from https://onestopdataanalysis.com/n50-genome/\ndef calculate_N50(list_of_lengths):\n \"\"\"Calculate N50 for a sequence of numbers.\n \n Args:\n list_of_lengths (list): List of numbers.\n \n Returns:\n float: N50 value.\n \n \"\"\"\n tmp = []\n for tmp_number in set(list_of_lengths):\n tmp += [tmp_number] * list_of_lengths.count(tmp_number) * tmp_number\n tmp.sort()\n \n if (len(tmp) % 2) == 0:\n median = (tmp[int(len(tmp) / 2) - 1] + tmp[int(len(tmp) / 2)]) / 2\n else:\n median = tmp[int(len(tmp) / 2)]\n \n return median\n\ndef main(args):\n\n options = parse_args()\n \n roh_region_dict = defaultdict(list)\n roh_region_length_dict = defaultdict(list)\n with open(options.inROH, 'r') as roh_file:\n for line in roh_file:\n parsed_line = line.strip().split('\\t')\n if parsed_line[0] == 'RG':\n print(parsed_line)\n sample_name = parsed_line[1]\n chromosome = parsed_line[2]\n start = parsed_line[3]\n end = parsed_line[4]\n length = parsed_line[5]\n num_markers = parsed_line[6]\n quality = parsed_line[7]\n roh_region_dict[sample_name].append([chromosome,start,end,length,num_markers,quality])\n roh_region_length_dict[sample_name].append(int(length))\n \n \n for sample_id in roh_region_dict.keys():\n with open('{}_{}'.format(sample_id,options.outReport), 'w') as bed_file:\n for roh_region in sorted(roh_region_dict[sample_id],key=lambda region_list:int(region_list[2])):\n region_chr = roh_region[0]\n region_start = roh_region[1]\n region_end = roh_region[2]\n bed_file.write('{}\\t{}\\t{}\\n'.format(region_chr,region_start,region_end))\n \n for sample_id in roh_region_dict.keys():\n sorted_list = sorted(roh_region_length_dict[sample_id])\n num_stat = len(sorted_list)\n min_stat = min(sorted_list)\n Q1_stat = sorted_list[-int(len(sorted_list)*0.75)]\n median_stat = sorted_list[-int(len(sorted_list)*0.5)]\n Q3_stat = sorted_list[-int(len(sorted_list)*0.25)]\n max_stat = max(sorted_list)\n n50 = calculate_N50(sorted_list)\n print(sample_id)\n print('number\\tmin\\tQ1\\tmedian\\tQ3\\tmax\\tn50')\n print('{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}'.format(num_stat, min_stat, Q1_stat, median_stat, Q3_stat, max_stat, n50))\n with open('{}_roh_lengths_list.{}'.format(sample_id,options.outReport), 'w') as lengths_file:\n for length in sorted_list:\n lengths_file.write('{}\\n'.format(length))\n \n \n \nif __name__ == \"__main__\":\n sys.exit(main(sys.argv))\n\n",
"import matplotlib\nmatplotlib.use('Agg')\nimport vcf, argparse, sys\nimport numpy as np\nimport pandas as pd\nimport math\nfrom scipy.stats import chisquare\nfrom collections import defaultdict\nimport matplotlib\nmatplotlib.use('Agg')\nimport vcf, argparse, sys\nimport numpy as np\nimport pandas as pd\nimport math\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n\ndef parse_args():\n \"\"\" \n Description:\n function 'parse_args' parses arguments from command-line and returns an argparse\n object containing the arguments and their values. Default values are 'False' if option\n is not listed in the command, else the option value is set to True.\n \"\"\"\n parser = argparse.ArgumentParser('Input bcftools roh tab-delimited file and output roh report and histogram.')\n parser.add_argument('-i', '--inROHdistA', type=str,\n help='Input 1st roh distribution filepath.')\n parser.add_argument('-j', '--inROHdistB', type=str,\n help='Input 2nd roh distribution filepath.')\n parser.add_argument('-l', '--regionLength', type=int,\n help='Input length of region used in calculating SROH.')\n parser.add_argument('-o', '--outReport', type=str,\n help='Output plot filename.')\n\n options = parser.parse_args()\n return options\n\ndef main(args):\n\n options = parse_args()\n \n roh_distribution_dict = defaultdict(list)\n with open(options.inROHdistA, 'r') as roh_file_a, open(options.inROHdistB, 'r') as roh_file_b:\n for line in roh_file_a:\n if 'sample_id' in line: continue\n parsed_line = line.strip().split('\\t')\n roh_distribution_dict['SROH'].extend([float(parsed_line[2]),float(parsed_line[3]),float(parsed_line[4]),float(parsed_line[5]),float(parsed_line[6])])\n roh_distribution_dict['SROH_length'].extend(['all','100kb','1mb', '1500kb', '5mb'])\n roh_distribution_dict['group'].extend(['No']*5)\n for line in roh_file_b:\n if 'sample_id' in line: continue\n parsed_line = line.strip().split('\\t')\n roh_distribution_dict['SROH'].extend([float(parsed_line[2]),float(parsed_line[3]),float(parsed_line[4]),float(parsed_line[5]),float(parsed_line[6])])\n roh_distribution_dict['SROH_length'].extend(['all','100kb','1mb', '1500kb', '5mb'])\n roh_distribution_dict['group'].extend(['Yes']*5)\n \n violin_df = pd.DataFrame(data=roh_distribution_dict) \n sns.set(style=\"whitegrid\", font_scale=1.5)\n \n fig, axes = plt.subplots(figsize=(10, 10)) \n order=[\"all\", \"100kb\", \"1mb\", \"1500kb\", \"5mb\"]\n sns.boxplot(\n x=\"SROH_length\", y=\"SROH\", hue=\"group\", data=violin_df, \n order=order,\n ax=axes\n )\n axes.set_xticklabels([\"All\", \"100 (kb)\", \"1 (mb)\", \"1.5 (mb)\", \"5 (mb)\"])\n axes.set_xlabel(\"Minimum ROH Length\")\n axes.legend(\"\")\n fig.savefig(\"roh_distribution_violin.{}.png\".format(options.outReport)) \n matplotlib.pyplot.close(fig)\n \nif __name__ == \"__main__\":\n sys.exit(main(sys.argv))\n\n"
] |
[
[
"matplotlib.use"
],
[
"matplotlib.use",
"pandas.DataFrame",
"matplotlib.pyplot.close",
"matplotlib.pyplot.subplots"
]
] |
orico/DeepMoji
|
[
"db1bdbd95e299c3fdbef9981e352cea79528b7b4"
] |
[
"deepmoji/create_vocab.py"
] |
[
"from __future__ import print_function, division\n\nimport glob\nimport json\nimport numpy as np\nimport uuid\nfrom .filter_utils import is_special_token\nfrom .word_generator import WordGenerator\nfrom collections import defaultdict, OrderedDict\nfrom .global_variables import SPECIAL_TOKENS, VOCAB_PATH\nfrom copy import deepcopy\n\n\nclass VocabBuilder():\n \"\"\" Create vocabulary with words extracted from sentences as fed from a\n word generator.\n \"\"\"\n\n def __init__(self, word_gen):\n # initialize any new key with value of 0\n self.word_counts = defaultdict(lambda: 0, {})\n self.word_length_limit = 30\n\n for token in SPECIAL_TOKENS:\n assert len(token) < self.word_length_limit\n self.word_counts[token] = 0\n self.word_gen = word_gen\n\n def count_words_in_sentence(self, words):\n \"\"\" Generates word counts for all tokens in the given sentence.\n\n # Arguments:\n words: Tokenized sentence whose words should be counted.\n \"\"\"\n for word in words:\n if 0 < len(word) and len(word) <= self.word_length_limit:\n try:\n self.word_counts[word] += 1\n except KeyError:\n self.word_counts[word] = 1\n\n def save_vocab(self, path=None):\n \"\"\" Saves the vocabulary into a file.\n\n # Arguments:\n path: Where the vocabulary should be saved. If not specified, a\n randomly generated filename is used instead.\n \"\"\"\n dtype = ([('word', '|S{}'.format(self.word_length_limit)), ('count', 'int')])\n np_dict = np.array(self.word_counts.items(), dtype=dtype)\n\n # sort from highest to lowest frequency\n np_dict[::-1].sort(order='count')\n data = np_dict\n\n if path is None:\n path = str(uuid.uuid4())\n\n np.savez_compressed(path, data=data)\n print(\"Saved dict to {}\".format(path))\n\n def get_next_word(self):\n \"\"\" Returns next tokenized sentence from the word geneerator.\n\n # Returns:\n List of strings, representing the next tokenized sentence.\n \"\"\"\n return self.word_gen.__iter__().next()\n\n def count_all_words(self):\n \"\"\" Generates word counts for all words in all sentences of the word\n generator.\n \"\"\"\n for words, _ in self.word_gen:\n self.count_words_in_sentence(words)\n\n\nclass MasterVocab():\n \"\"\" Combines vocabularies.\n \"\"\"\n\n def __init__(self):\n\n # initialize custom tokens\n self.master_vocab = {}\n\n def populate_master_vocab(self, vocab_path, min_words=1, force_appearance=None):\n \"\"\" Populates the master vocabulary using all vocabularies found in the\n given path. Vocabularies should be named *.npz. Expects the\n vocabularies to be numpy arrays with counts. Normalizes the counts\n and combines them.\n\n # Arguments:\n vocab_path: Path containing vocabularies to be combined.\n min_words: Minimum amount of occurences a word must have in order\n to be included in the master vocabulary.\n force_appearance: Optional vocabulary filename that will be added\n to the master vocabulary no matter what. This vocabulary must\n be present in vocab_path.\n \"\"\"\n\n paths = glob.glob(vocab_path + '*.npz')\n sizes = {path: 0 for path in paths}\n dicts = {path: {} for path in paths}\n\n # set up and get sizes of individual dictionaries\n for path in paths:\n np_data = np.load(path)['data']\n\n for entry in np_data:\n word, count = entry\n if count < min_words:\n continue\n if is_special_token(word):\n continue\n dicts[path][word] = count\n\n sizes[path] = sum(dicts[path].values())\n print('Overall word count for {} -> {}'.format(path, sizes[path]))\n print('Overall word number for {} -> {}'.format(path, len(dicts[path])))\n\n vocab_of_max_size = max(sizes, key=sizes.get)\n max_size = sizes[vocab_of_max_size]\n print('Min: {}, {}, {}'.format(sizes, vocab_of_max_size, max_size))\n\n # can force one vocabulary to always be present\n if force_appearance is not None:\n force_appearance_path = [p for p in paths if force_appearance in p][0]\n force_appearance_vocab = deepcopy(dicts[force_appearance_path])\n print(force_appearance_path)\n else:\n force_appearance_path, force_appearance_vocab = None, None\n\n # normalize word counts before inserting into master dict\n for path in paths:\n normalization_factor = max_size / sizes[path]\n print('Norm factor for path {} -> {}'.format(path, normalization_factor))\n\n for word in dicts[path]:\n if is_special_token(word):\n print(\"SPECIAL - \", word)\n continue\n normalized_count = dicts[path][word] * normalization_factor\n\n # can force one vocabulary to always be present\n if force_appearance_vocab is not None:\n try:\n force_word_count = force_appearance_vocab[word]\n except KeyError:\n continue\n # if force_word_count < 5:\n # continue\n\n if word in self.master_vocab:\n self.master_vocab[word] += normalized_count\n else:\n self.master_vocab[word] = normalized_count\n\n print('Size of master_dict {}'.format(len(self.master_vocab)))\n print(\"Hashes for master dict: {}\".format(\n len([w for w in self.master_vocab if '#' in w[0]])))\n\n def save_vocab(self, path_count, path_vocab, word_limit=100000):\n \"\"\" Saves the master vocabulary into a file.\n \"\"\"\n\n # reserve space for 10 special tokens\n words = OrderedDict()\n for token in SPECIAL_TOKENS:\n # store -1 instead of np.inf, which can overflow\n words[token] = -1\n\n # sort words by frequency\n desc_order = OrderedDict(sorted(self.master_vocab.items(),\n key=lambda kv: kv[1], reverse=True))\n words.update(desc_order)\n\n # use encoding of up to 30 characters (no token conversions)\n # use float to store large numbers (we don't care about precision loss)\n np_vocab = np.array(words.items(),\n dtype=([('word', '|S30'), ('count', 'float')]))\n\n # output count for debugging\n counts = np_vocab[:word_limit]\n np.savez_compressed(path_count, counts=counts)\n\n # output the index of each word for easy lookup\n final_words = OrderedDict()\n for i, w in enumerate(words.keys()[:word_limit]):\n final_words.update({w: i})\n with open(path_vocab, 'w') as f:\n f.write(json.dumps(final_words, indent=4, separators=(',', ': ')))\n\n\ndef all_words_in_sentences(sentences):\n \"\"\" Extracts all unique words from a given list of sentences.\n\n # Arguments:\n sentences: List or word generator of sentences to be processed.\n\n # Returns:\n List of all unique words contained in the given sentences.\n \"\"\"\n vocab = []\n if isinstance(sentences, WordGenerator):\n sentences = [s for s, _ in sentences]\n\n for sentence in sentences:\n for word in sentence:\n if word not in vocab:\n vocab.append(word)\n\n return vocab\n\n\ndef extend_vocab_in_file(vocab, max_tokens=10000, vocab_path=VOCAB_PATH):\n \"\"\" Extends JSON-formatted vocabulary with words from vocab that are not\n present in the current vocabulary. Adds up to max_tokens words.\n Overwrites file in vocab_path.\n\n # Arguments:\n new_vocab: Vocabulary to be added. MUST have word_counts populated, i.e.\n must have run count_all_words() previously.\n max_tokens: Maximum number of words to be added.\n vocab_path: Path to the vocabulary json which is to be extended.\n \"\"\"\n try:\n with open(vocab_path, 'r') as f:\n current_vocab = json.load(f)\n except IOError:\n print('Vocabulary file not found, expected at ' + vocab_path)\n return\n\n extend_vocab(current_vocab, vocab, max_tokens)\n\n # Save back to file\n with open(vocab_path, 'w') as f:\n json.dump(current_vocab, f, sort_keys=True, indent=4, separators=(',', ': '))\n\n\ndef extend_vocab(current_vocab, new_vocab, max_tokens=10000):\n \"\"\" Extends current vocabulary with words from vocab that are not\n present in the current vocabulary. Adds up to max_tokens words.\n\n # Arguments:\n current_vocab: Current dictionary of tokens.\n new_vocab: Vocabulary to be added. MUST have word_counts populated, i.e.\n must have run count_all_words() previously.\n max_tokens: Maximum number of words to be added.\n\n # Returns:\n How many new tokens have been added.\n \"\"\"\n if max_tokens < 0:\n max_tokens = 10000\n\n words = OrderedDict()\n\n # sort words by frequency\n desc_order = OrderedDict(sorted(new_vocab.word_counts.items(),\n key=lambda kv: kv[1], reverse=True))\n words.update(desc_order)\n\n base_index = len(current_vocab.keys())\n added = 0\n for word in words:\n if added >= max_tokens:\n break\n if word not in current_vocab.keys():\n current_vocab[word] = base_index + added\n added += 1\n\n return added\n"
] |
[
[
"numpy.savez_compressed",
"numpy.load"
]
] |
RElbers/strotss-pytorch
|
[
"0c2550d713d9b17711fba3f7f9621d1d7768a5eb"
] |
[
"imgs/make_table.py"
] |
[
"from math import ceil, floor\nfrom pathlib import Path\n\nimport cv2\nimport numpy as np\n\nfrom util import load, save\n\n\n\ndef pad_square(img):\n h, w, c = img.shape\n size = max(h, w)\n pad_h = size - h\n pad_w = size - w\n\n img = np.pad(img, ((floor(pad_h / 2), ceil(pad_h / 2)),\n (floor(pad_w / 2), ceil(pad_w / 2)),\n (0, 0)),\n 'constant',\n constant_values=255)\n return img\n\n\ndef f(img):\n img = pad_square(img)\n\n _, w__, _ = img.shape\n w_ = w__ * r\n pad = w_ - w__\n pad = pad / 2\n\n img = np.pad(img, ((0, 0), (floor(pad), ceil(pad)), (0, 0)), 'constant', constant_values=255)\n\n img = cv2.resize(img, (w, h), interpolation=cv2.INTER_AREA)\n img = np.pad(img, ((8, 8), (8, 8), (0, 0)), 'constant', constant_values=255)\n return img\n\n\npath = Path(rf\"../replicate_style\")\n# path = Path(rf\"./replicate_content\")\n\nh = 440\nw = 658\nr = w / h\n\nstyles = [rf'./styles/style_{i:02}.png' for i in range(5)]\nstyles = [load(f) for f in styles]\nstyles = [f(img) for img in styles]\n\ncontents = [rf'./contents/content_{i:02}.png' for i in range(5)]\ncontents = [load(f) for f in contents]\ncontents = [f(img) for img in contents]\n\nrows = []\nrows.append(np.hstack([np.ones_like(styles[0]) *255, *styles]))\nfor j in range(5):\n row = [contents[j]]\n\n for i in range(5):\n file = path.joinpath(rf'output_{j:02}_{i:02}.png')\n img = load(file)[:h, :w]\n\n img = np.pad(img, ((8, 8), (8, 8), (0, 0)), 'constant', constant_values=255)\n\n row.append(img)\n\n row = np.hstack(row)\n rows.append(row)\n\nimg = np.vstack(rows)\n\nsave('tbl.png', img)\n"
] |
[
[
"numpy.hstack",
"numpy.pad",
"numpy.ones_like",
"numpy.vstack"
]
] |
facebbook/jina
|
[
"e8079af3d58f1de0f51f8aef6cdf1eb3d87a9873"
] |
[
"tests/integration/evaluation/rank/test_evaluation.py"
] |
[
"import os\n\nimport numpy as np\n\nfrom jina import Document\nfrom jina.flow import Flow\n\nfrom tests import validate_callback\n\n\ndef test_evaluation(tmpdir, mocker):\n os.environ['JINA_TEST_RANKING_EVALUATION'] = str(tmpdir)\n\n def index_documents():\n \"\"\"Index Documents:\n doc: tag__id = 0\n tag__dummy_score = 0\n embedding = 0\n doc: tag__id = 1\n tag__dummy_score = -1\n embedding = 1\n doc: tag__id = 2\n tag__dummy_score = -2\n embedding = 2\n \"\"\"\n with Document() as doc0:\n doc0.tags['id'] = '0'\n doc0.tags['dummy_score'] = 0\n doc0.embedding = np.array([0])\n\n with Document() as doc1:\n doc1.tags['id'] = '1'\n doc1.tags['dummy_score'] = -1\n doc1.embedding = np.array([1])\n\n with Document() as doc2:\n doc2.tags['id'] = '2'\n doc2.tags['dummy_score'] = -2\n doc2.embedding = np.array([2])\n\n return [doc0, doc1, doc2]\n\n with Flow.load_config('flow-index.yml') as index_flow:\n index_flow.index(inputs=index_documents)\n\n def validate_evaluation_response(resp):\n assert len(resp.docs) == 2\n for doc in resp.docs:\n assert (\n len(doc.evaluations) == 8\n ) # 2 evaluation Pods with 4 evaluations each\n\n doc = resp.docs[0]\n assert len(doc.matches) == 2\n assert doc.evaluations[0].op_name == 'PrecisionEvaluator@1'\n assert doc.evaluations[0].value == 1.0\n assert doc.evaluations[1].op_name == 'PrecisionEvaluator@2'\n assert doc.evaluations[1].value == 0.5\n assert doc.evaluations[2].op_name == 'RecallEvaluator@1'\n assert doc.evaluations[2].value == 0.5\n assert doc.evaluations[3].op_name == 'RecallEvaluator@2'\n assert doc.evaluations[3].value == 0.5\n\n assert doc.evaluations[4].op_name == 'PrecisionEvaluator@1'\n assert doc.evaluations[4].value == 1.0\n assert doc.evaluations[5].op_name == 'PrecisionEvaluator@2'\n assert doc.evaluations[5].value == 0.5\n assert doc.evaluations[6].op_name == 'RecallEvaluator@1'\n assert doc.evaluations[6].value == 0.5\n assert doc.evaluations[7].op_name == 'RecallEvaluator@2'\n assert doc.evaluations[7].value == 0.5\n\n doc = resp.docs[1]\n assert doc.evaluations[0].op_name == 'PrecisionEvaluator@1'\n assert doc.evaluations[0].value == 1.0\n assert doc.evaluations[1].op_name == 'PrecisionEvaluator@2'\n assert doc.evaluations[1].value == 1.0\n assert doc.evaluations[2].op_name == 'RecallEvaluator@1'\n assert doc.evaluations[2].value == 0.5\n assert doc.evaluations[3].op_name == 'RecallEvaluator@2'\n assert doc.evaluations[3].value == 1.0\n\n assert doc.evaluations[4].op_name == 'PrecisionEvaluator@1'\n assert doc.evaluations[4].value == 1.0\n assert doc.evaluations[5].op_name == 'PrecisionEvaluator@2'\n assert doc.evaluations[5].value == 1.0\n assert doc.evaluations[6].op_name == 'RecallEvaluator@1'\n assert doc.evaluations[6].value == 0.5\n assert doc.evaluations[7].op_name == 'RecallEvaluator@2'\n assert doc.evaluations[7].value == 1.0\n\n def doc_groundtruth_evaluation_pairs():\n with Document() as doc0:\n doc0.embedding = np.array([0])\n\n with Document() as groundtruth0:\n m1 = Document(id='1' * 16)\n m1.score.value = -1\n match0 = groundtruth0.matches.append(m1)\n match0.tags['id'] = '0'\n m2 = Document(id='2' * 16)\n m2.score.value = -1\n match1 = groundtruth0.matches.append(m2)\n match1.tags['id'] = '2'\n # top_k is set to 2 for VectorSearchDriver\n # expects as matches [0, 2] but given [0, 1]\n # Precision@1 = 100%\n # Precision@2 = 50%\n # Recall@1 = 100%\n # Recall@2 = 50%\n\n # expects as ranked [0, 2] but given [0, 1]\n # Precision@1 = 100%\n # Precision@2 = 50%\n # Recall@1 = 100%\n # Recall@2 = 50%\n\n with Document() as doc1:\n doc1.embedding = np.array([2])\n\n with Document() as groundtruth1:\n m1 = Document(id='1' * 16)\n m1.score.value = -1\n match0 = groundtruth1.matches.append(m1)\n match0.tags['id'] = '1'\n m2 = Document(id='2' * 16)\n m2.score.value = -1\n match1 = groundtruth1.matches.append(m2)\n match1.tags['id'] = '2'\n # expects as matches [1, 2] but given [2, 1]\n # Precision@1 = 100%\n # Precision@2 = 100%\n # Recall@1 = 100%\n # Recall@2 = 100%\n\n # expects as ranked [1, 2] but given [2, 1]\n # Precision@1 = 100%\n # Precision@2 = 100%\n # Recall@1 = 100%\n # Recall@2 = 100%\n\n return [(doc0, groundtruth0), (doc1, groundtruth1)]\n\n response_mock = mocker.Mock()\n with Flow.load_config('flow-evaluate.yml') as evaluate_flow:\n evaluate_flow.search(\n inputs=doc_groundtruth_evaluation_pairs, on_done=response_mock, top_k=2\n )\n\n del os.environ['JINA_TEST_RANKING_EVALUATION']\n validate_callback(response_mock, validate_evaluation_response)\n"
] |
[
[
"numpy.array"
]
] |
yousszr/Dji-TelloPy-PoseEstimation-FaceTracking
|
[
"40ba58c307ea081a6ddef470ca2557b48df33680"
] |
[
"src/videos.py"
] |
[
"import cv2;\nimport imutils\nimport numpy as np\n\nface_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml');\nnet = cv2.dnn.readNetFromCaffe('deploy.prototxt.txt', 'res10_300x300_ssd_iter_140000.caffemodel')\nvideo = cv2.VideoCapture(0);\n\nwhile True:\n check, frame = video.read();\n \"\"\"convert frame to cv2 image and show\"\"\"\n frame = imutils.resize(frame, width=400)\n \n #CATTURO I FRAME E GLI CONVERTO IN BLOB\n (h, w) = frame.shape[:2] \n blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 1.0,\n (300, 300), (104.0, 177.0, 123.0))\n \n #passo i blob alla rete neurale per la identificazione delle faccie\n net.setInput(blob)\n detections = net.forward()\n \n \n #loop sulle faccie rilevate\n for i in range(0, detections.shape[2]):\n \n ##probabilità della predizione\n confidence = detections[0, 0, i, 2]\n\n # Filtra le faccie errate\n if confidence < 0.5:\n continue\n \n #calcolo delle coordinate del box\n box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\n (startX, startY, endX, endY) = box.astype(\"int\")\n \n \n \n \n #disegno sul frame\n text = \"{:.2f}%\".format(confidence * 100)\n y = startY - 10 if startY - 10 > 10 else startY + 10\n cv2.rectangle(frame, (startX, startY), (endX, endY),\n (0, 0, 255), 2)\n \n \n cv2.putText(frame, text, (startX, y),\n cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2)\n \n \n\n cv2.imshow('tello', frame)\n _ = cv2.waitKey(1) & 0xFF\n\nvideo.release();\ncv2.destroyAllWindows();\n"
] |
[
[
"numpy.array"
]
] |
danielsuo/toy_flood
|
[
"471d3c4091d86d4a00fbf910937d4e60fdaf79a1"
] |
[
"skgaip/tspdb/tspdb/tests/test_module_local.py"
] |
[
"\nimport numpy as np\nfrom tspdb.src.pindex.predict import get_prediction_range, get_prediction\nfrom tspdb.src.pindex.pindex_managment import TSPI, load_pindex\nfrom tspdb.src.pindex.pindex_utils import index_ts_mapper\nimport time\nimport timeit\nimport pandas as pd\nfrom tspdb.src.hdf_util import read_data\nfrom tspdb.src.tsUtils import randomlyHideValues\nfrom scipy.stats import norm\nfrom sklearn.metrics import r2_score\nimport tspdb\nimport psycopg2\n\ndef r2_var(y,y_h,X):\n average = np.mean(X**2) - np.mean(X)**2\n return 1 - sum((y-y_h)**2)/sum((y-average)**2)\n\ndef create_table_data():\n\n\tobs = np.arange(10**5).astype('float')\n\tmeans = obs\n\tvar = np.zeros(obs.shape)\n\tobs_9 = randomlyHideValues(np.array(obs), 0.9)[0]\n\tobs_7 = randomlyHideValues(np.array(obs), 0.7)[0]\n\tprint(obs_9)\n\tdf = pd.DataFrame(data ={'ts':obs, 'means': means, 'ts_9':obs_9, 'ts_7' : obs_7,'var': var }) \n\tdf.to_csv('testdata/tables/ts_basic_5.csv',index_label = 'time')\n\n\ttimestamps = pd.date_range('2012-10-01 00:00:00', periods = 10**5, freq='5s')\n\tdf.index = timestamps\n\tdf.to_csv('testdata/tables/ts_basic_ts_5_5.csv', index_label = 'time')\n\t\n\n\t# real time series variance constant\n\tdata = read_data('testdata/MixtureTS2.h5')\n\tobs = data['obs'][:]\n\tmeans = data['means'][:]\n\tvar = np.ones(obs.shape)\n\tobs_9 = randomlyHideValues(np.array(obs), 0.9)[0]\n\tobs_7 = randomlyHideValues(np.array(obs), 0.7)[0]\n\tdf = pd.DataFrame(data ={'ts':obs, 'means': means, 'ts_9':obs_9, 'ts_7' : obs_7 ,'var': var }) \n\tdf.index_label = 'time'\n\tdf.to_csv('testdata/tables/MixtureTS2.csv', index_label = 'time')\n\t\n\t# real time series variance constant\n\tdata = read_data('testdata/MixtureTS.h5')\n\tobs = data['obs'][:]\n\tmeans = data['means'][:]\n\tvar = np.ones(obs.shape)\n\tobs_9 = randomlyHideValues(np.array(obs), 0.9)[0]\n\tobs_7 = randomlyHideValues(np.array(obs), 0.7)[0]\n\tdf = pd.DataFrame(data ={'ts':obs, 'means': means, 'ts_9':obs_9, 'ts_7' : obs_7,'var': var }) \n\tdf.to_csv('testdata/tables/MixtureTS.csv', index_label = 'time')\n\t\n\t# real time series varaince harmonics\n\tdata = read_data('testdata/MixtureTS_var.h5')\n\tobs = data['obs'][:]\n\tmeans = data['means'][:]\n\tvar = data['var'][:]\n\tobs_9 = randomlyHideValues(np.array(obs), 0.9)[0]\n\tobs_7 = randomlyHideValues(np.array(obs), 0.7)[0]\n\tdf = pd.DataFrame(data ={'ts':obs, 'means': means, 'ts_9':obs_9, 'ts_7' : obs_7, 'var': var }) \n\tdf.to_csv('testdata/tables/MixtureTS_var.csv', index_label = 'time')\n\ndef create_tables(interface):\n\tdir_ = tspdb.__path__[0]+'/tests/'\t\n\tfor table in ['mixturets2','ts_basic_5','ts_basic_ts_5_5','mixturets_var']:\n\t\tdf = pd.read_csv(dir_+'testdata/tables/%s.csv'%table) \n\t\tif table == 'ts_basic_ts_5_5': df['time'] = df['time'].astype('datetime64[ns]')\n\t\tinterface.create_table(table, df, 'time', include_index = False)\n\t\n\ndef update_test(interface, init_points = 10**4 , update_points = [1000,100,5000,10000], T = 1000, direct_var = True ,index_name = 'ts_basic_test_pindex'):\n\tdf = pd.DataFrame(data ={'ts': np.arange(init_points).astype('float')}) \n\tinterface.create_table('ts_basic_test', df, 'row_id', index_label='row_id')\n\ttime_series_table = ['ts_basic_test','ts', 'row_id']\n\tT0 = 1000\n\tgamma = 0.5\n\tk = 2\n\tk_var = 1\n\tagg_interval = 1.\n\tconn = interface.engine.raw_connection()\n\tcur = conn.cursor()\n\tcur.execute('''SELECT create_pindex('%s','%s','%s','%s', \"T\" => %s, k => %s, k_var => %s, agg_interval => %s, var_direct => %s)'''%('ts_basic_test','row_id','ts', index_name, T, k,k_var, agg_interval, direct_var))\n\tcur.close()\n\tconn.commit()\n\tconn.close()\n\tfor points in update_points:\n\t\tdf = pd.DataFrame(data = {'ts':np.arange(init_points,points+init_points).astype('float')}, index = np.arange(init_points,points+init_points) ) \n\t\tinterface.bulk_insert('ts_basic_test', df, index_label='row_id')\n\t\tinit_points += points\n\t\tprint ('successfully updated %s points' %points)\n\t\t\ndef ts_table_tests(init_points = 10**4 , update_points = [1000,100,5000,10000], T = 1000, direct_var = True ,index_name = 'ts_basic_ts_pindex'):\n\tinterface = SqlImplementation(driver=\"postgresql\", host=\"localhost\", database=\"querytime_test\",user=\"aalomar\",password=\"AAmit32lids\")\n\t\n\tdf = pd.DataFrame(data ={'ts': np.arange(init_points).astype('float')}) \n\ttimestamps = pd.date_range('2012-10-01 00:00:00', periods = init_points+1, freq='5s')\n\tend = timestamps[-1]\n\tdf.index = timestamps[:-1]\n\tinterface.create_table('ts_basic_ts', df, 'timestamp', index_label='timestamp')\n\ttime_series_table = ['ts_basic_ts','ts', 'timestamp']\n\tT0 = 1000\n\tgamma = 0.5\n\tk = 2\n\tk_var = 1\n\tTSPD = TSPI(_dir = 'C:/Program Files/PostgreSQL/10/data/', agg_interval = 5, T = T,T_var = T, rank = k, rank_var = k_var, col_to_row_ratio = 10, index_name = index_name,gamma = gamma, interface= interface ,time_series_table = time_series_table, direct_var = direct_var )\n\tTSPD.create_index()\n\tinterface = SqlImplementation(driver=\"postgresql\", host=\"localhost\", database=\"querytime_test\",user=\"aalomar\",password=\"AAmit32lids\")\n\tfor points in update_points:\n\t\tdf = pd.DataFrame(data = {'ts':np.arange(init_points,points+init_points).astype('float')} ) \n\t\ttimestamps = pd.date_range(end, periods = points+1, freq='5s')\n\t\tend = timestamps[-1]\n\t\tdf.index = timestamps[:-1]\n\t\tinterface.bulk_insert('ts_basic_ts', df, index_label='timestamp')\n\t\tinit_points += points\n\t\tprint ('successfully updated %s points' %points)\n\n\t\ndef create_pindex_test(interface,table_name, T,T_var, k ,k_var, direct_var,value_column= ['ts'], index_name = None , agg_interval = 1., col_to_row_ratio= 10, time_column = 'row_id'):\n\n\tT0 = 1000\n\tgamma = 0.5\n\tif index_name is None: index_name = 'pindex'\n\tvalue_column = ','.join(value_column)\n\tinterface.engine.execute('''SELECT create_pindex('%s','%s','{%s}','%s', \"T\" => %s,\"t_var\" =>%s, k => %s, k_var => %s, agg_interval => %s, var_direct => %s, col_to_row_ratio => %s)'''%(table_name,time_column, value_column, index_name, T, T_var, k,k_var, agg_interval, direct_var, col_to_row_ratio))\n\ndef create_pindex_test2(interface,table_name, T,T_var, k ,k_var, direct_var,value_column= ['ts'], index_name = None , agg_interval = 1., col_to_row_ratio= 10, time_column = 'row_id'):\n\tdatabase = 'querytime_test'\n\tuser = 'postgres'\n\tpassword = '0505'\n\thost = 'localhost'\n\tconn_string = \"host='%s' dbname='%s' user='%s' password='%s'\" %(host, database, user, password) \n\tvalue_column = ','.join(value_column)\n\tconn = psycopg2.connect(conn_string)\n\tcursor = conn.cursor()\n\tcursor.execute(\"\"\"SELECT create_pindex('%s','%s','{%s}','%s', \"T\" => %s,\"t_var\" =>%s, k => %s, k_var => %s, agg_interval => %s, var_direct => %s, col_to_row_ratio => %s)\"\"\"%(table_name,time_column, value_column, index_name, T, T_var, k,k_var, agg_interval, direct_var, col_to_row_ratio))\n\tconn.commit()\n\tconn.close()\t\n\n\ndef range_prediction_queries_test(index_name, table_name, max_):\n\t\n\tT1 = [0,0,max_-10, max_-15000, max_] + list((max_+1000) * np.random.random(10))\n\tT2 = [10, 10**5, max_-1, max_, max_ +10] + list((max_+1000) * np.random.random(10))\n\tT1 = np.array(T1).astype(int)\n\tT2 = np.array(T2).astype(int)\n\tfor t1_,t2_ in zip(T1,T2):\n\t\tt1,t2 = sorted([t1_,t2_])\n\t\t# print (')\n\t\t# try:\n\t\tget_prediction_range(index_name, table_name, 'ts', 'row_id', interface, int(t1),int(t2), uq = True)\n\t\t# except: print('failure to query range between %s and %s' % (t1,t2))\n\ndef prediction_queries_test(index_name, table_name, max_):\n\t\n\tT1 = [0,max_-10, max_-1000, max_+1, max_+10] + list((max_+1000) * np.random.random(50))\n\tT1 = np.array(T1).astype(int)\n\n\tfor t1 in T1:\n\t\t# try: \n\t\t\tget_prediction(index_name, table_name, 'ts', 'row_id', interface, int(t1), uq = True)\n\t\t# except: print('failure to query point %s' %t1)\n\ndef prediction_queries_accuracy_test(max_, index_name = \"tspdb.ts_basic2_pindex2\", table_name = \"ts_basic2\"):\n\tT1 = [100000,max_-1000, max_] + list((max_-1) * np.random.random(100))\n\tT1 = np.array(T1).astype(int)\n\t\n\tfor t1 in T1:\n\t\tprint ('t = '+str(t1))\n\t\tA,_ = get_prediction(index_name, table_name, 'ts', 'row_id', interface, int(t1))\n\t\tprint (t1,A )\n\t\tassert abs(A - t1) < 1e-3\n\t\n\ndef range_prediction_queries_accuracy_test( index_name, file_name, table_name , value_column, max_ ):\n\tmax_ = interface.engine.execute('Select \"last_TS_inc\" from tspdb.'+index_name+'_meta').fetchone()[0]\n\tT1 = [0, max_]\n\tT2 = [max_, 10**5-1]\n\tT1 = np.array(T1).astype(int)\n\tT2 = np.array(T2).astype(int)\n\tdf = pd.read_csv('testdata/tables/%s.csv'%file_name) \n\tmeans = df['means']\n\tvar = df['var']\n\talpha = norm.ppf(1./2 + 95./200)\n\n\tfor t1_,t2_ in zip(T1,T2):\n\t\tt1,t2 = sorted([t1_,t2_])\n\t\tM = np.array(interface.engine.execute(\"select * from predict_range(%s, %s, %s,%s, %s, uq => True)\", (table_name, value_column,int(t1),int(t2),index_name)).fetchall()).astype(np.float)\n\t\tA = M[:,0]\n\t\test_var = (abs(M[:,0] - M[:,1])/alpha)**2\n\t\tprint (t1,t2,' rmse: ',np.sqrt(np.mean(np.square(A - means[t1:t2+1]))), np.sqrt(np.mean(np.square(est_var - var[t1:t2+1]))))\n\t\tprint (t1,t2,'r2: ',r2_score(means[t1:t2+1],A ), r2_var(var[t1:t2+1],est_var, df['ts'][t1:t2+1]))\n\t\t# print('first ten (predicted, actual) points for var: ', [(i,j) for i,j in zip(var[t1: t1+10],est_var[:10])])\n\t\t#assert abs(np.max(A - np.arange(t1,t2+1))) < 1e-3\n\ndef metrics_test(interface):\n\tcreate_pindex_test(interface,'mixturets2', 100000,100000, 3, 1, True, index_name = 'test_pindex', time_column = 'time',agg_interval = 1. )\n\tratio = {1:10, 2:20, 4:16, 3:18, 5:20,6:24,8:16,10:20,12:24}\n\tts_time = []\n\tdb_time = []\n\tinsert_time_2 ,insert_time = [], []\n\tpredict_time, select_time,predict_time_var, forecast_time_var, forecast_time, forecast_range_time_var, forecast_range_time, predict_range_time_var, predict_range_time, select_time_range = [],[],[],[],[],[],[],[],[],[]\n\tfor ii, ts in enumerate([1]):\n\t\tprint(ts)\n\t\tdf = pd.DataFrame()\n\t\tfor i in range(ts):\n\t\t\tcol = 'ts%s'%i\n\t\t\tdf[col]= np.arange(10**6) + np.random.normal(0,1,10**6)\n\t\t\n\t\t# Throughput test\n\t\tinterface.create_table('ts_basic', df, 'time', include_index = True, index_label = 'time', load_data=False)\n\t\tdf.to_csv('test.csv', sep='\\t', header=False, index=True, index_label='time')\n\t\tconn = interface.engine.raw_connection()\n\t\tcur = conn.cursor()\n\t\tt = time.time()\n\t\tcur.copy_from(open('test.csv','rb'), 'ts_basic', null=\"\")\n\t\tconn.commit()\n\t\tconn.close()\n\t\tdb_time.append(time.time() - t)\n\t\t\n\t\tinterface.create_table('ts_basic_%s'%ts, df, 'time', include_index = True, index_label = 'time', load_data=False)\n\t\tinterface.bulk_insert('ts_basic_%s'%ts, df, include_index=True, index_label='time')\n\t\tcolumns = ['ts%s'%i for i in range(ts)]\n\t\tt = time.time()\n\t\tcreate_pindex_test2(interface,'ts_basic_%s'%ts, 2500000,2500000, 3, 1, True, index_name = 'test_pindex',value_column= columns, time_column = 'time',agg_interval = 1., col_to_row_ratio = ratio[ts] )\n\t\tts_time.append(time.time() - t)\n\t\t\n\t\t#update test\n\t\tbatch = 100\n\t\tno_batches = 1000\n\t\tinsert_time_2.append(0)\n\t\tinsert_time.append(0)\n\t\tfor i in range(no_batches) :\n\t\t\t\n\t\t\tdf = pd.DataFrame()\n\t\t\tdf['time'] = np.arange(10**6 + i *batch, 10**6 + (i+1)*batch) \n\t\t\tfor n in range(ts):\n\t\t\t\tcol = 'ts%s'%n\n\t\t\t\tdf[col]= np.arange(10**6 + i *batch, 10**6 + (i+1)*batch) + np.random.normal(0,1,batch)\n\t\t\tcols = ['time']+['ts%s'%n for n in range(ts)]\n\t\t\tsql1 = \"INSERT INTO ts_basic\"\n\t\t\tsql = \"(\"+','.join(cols)+\") VALUES \"\n\t\t\tsql2 = \"INSERT INTO ts_basic_%s\"%ts\n\t\t\tfor row in df.values.astype(str):\n\t\t\t\tvalues = '('+','.join(row)+'),'\n\t\t\t\tsql = sql + values\n\t\t\t\n\t\t\tsql = sql[:-1]\n\t\t\t\n\t\t\t# df.to_csv('test.csv', sep='\\t', header=False, index=True, index_label='time')\n\t\t\t\n\t\t\tconn = interface.engine.raw_connection()\n\t\t\t\n\t\t\tt = time.time()\n\t\t\tcur = conn.cursor()\n\t\t\t# cur.copy_from(open('test.csv','rb'), 'ts_basic', null=\"\")\n\t\t\tcur.execute(sql1+sql)\n\t\t\tconn.commit()\n\t\t\tinsert_time[ii]+= (time.time() - t)\n\t\t\t\n\t\t\tt = time.time()\n\t\t\tcur = conn.cursor()\n\t\t\t# cur.copy_from(open('test.csv','rb'), 'ts_basic_%s'%ts, null=\"\")\n\t\t\tcur.execute(sql2+sql)\n\t\t\tconn.commit()\n\t\t\tinsert_time_2[ii] += (time.time() - t)\n\n\t\t\tconn.close()\n\n\n\t\tt_f = interface.engine.execute('select \"last_TS_inc\"/%s from tspdb.test_pindex_meta;'%ts).fetchone()[0]\n\t\t# prediction queries\n\t\tN = 100\n\t\tT = (10**6*np.random.random(N)).astype(int)\n\t\t\n\t\tinterface.engine.execute(\"select * from predict('ts_basic_%s', 'ts0', 0, 'test_pindex', uq => false)\"%ts)\n\t\t\n\n\t\ttt = []\n\t\tfor t in T: \n\t\t\tt1 = time.time()\n\t\t\tinterface.engine.execute(\"select * from predict('ts_basic_%s', 'ts0', %s, 'test_pindex', uq => false)\"%(ts,t)) \n\t\t\ttt.append((time.time() - t1))\n\t\tpredict_time.append(np.median(tt))\n\n\t\t\n\t\ttt = []\n\t\tfor t in T: \n\t\t\tt1 = time.time()\n\t\t\tinterface.engine.execute(\"select * from predict('ts_basic_%s', 'ts0', %s, 'test_pindex', uq => true)\"%(ts,t)) \n\t\t\ttt.append(time.time() - t)\n\t\tpredict_time_var.append(np.median(tt))\n\t\t\n\t\tM = 100\n\t\t\n\t\ttt = []\n\t\tfor t in range(M): \n\t\t\tt1 = time.time()\n\t\t\tinterface.engine.execute(\"select * from predict('ts_basic_%s', 'ts0', %s, 'test_pindex', uq => true)\"%(ts,t_f)) \n\t\t\ttt.append((time.time() - t1))\n\t\tforecast_time_var.append(np.median(tt))\n\n\t\ttt = []\n\t\tfor t in range(M): \n\t\t\tt1 = time.time()\t\n\t\t\tinterface.engine.execute(\"select * from predict('ts_basic_%s', 'ts0', %s, 'test_pindex', uq => false)\"%(ts,t_f)) \n\t\t\ttt.append((time.time() - t1))\n\t\tforecast_time.append(np.median(tt))\n\n\t\t\n\t\ttt = []\n\t\tfor t in T: \n\t\t\tt1 = time.time()\n\t\t\ta = interface.engine.execute(\"select ts0 from ts_basic_%s where time = %s\"%(ts,t,))\n\t\t\ttt.append((time.time() - t1))\n\t\tselect_time.append(np.median(tt))\n\n\n\t\tT = ((10**6-1000)*np.random.random(N)).astype(int)\n\t\t\n\t\ttt = []\n\t\tfor t in T: \n\t\t\tt1 = time.time()\n\t\t\tinterface.engine.execute(\"select ts0 from ts_basic_%s where time >= %s and time <= %s\"%(ts, t,t+1000,))\n\t\t\ttt.append(time.time() - t1)\n\t\tselect_time_range.append(np.median(tt))\n\n\t\ttt = []\n\t\tfor t in T: \n\t\t\tt1 = time.time()\n\t\t\tinterface.engine.execute(\"select * from predict_range('ts_basic_%s', 'ts0', %s,%s, 'test_pindex', uq => false)\"%(ts,t, t+1000,)) \n\t\t\ttt.append(time.time() - t1)\n\t\tpredict_range_time.append(np.median(tt))\n\t\t\n\t\ttt = []\n\t\tfor t in T: \n\t\t\tt1 = time.time()\n\t\t\tinterface.engine.execute(\"select * from predict_range('ts_basic_%s', 'ts0', %s,%s, 'test_pindex', uq => true)\"%(ts,t, t+1000,)) \n\t\t\ttt.append(time.time() - t1)\n\t\tpredict_range_time_var.append(np.median(tt))\n\t\t\n\t\ttt = []\n\t\tfor t in T: \n\t\t\tt1 = time.time()\n\t\t\tinterface.engine.execute(\"select * from predict_range('ts_basic_%s', 'ts0', %s,%s, 'test_pindex', uq => false)\"%(ts,t_f, t_f+1000)) \n\t\t\ttt.append(time.time() - t1)\n\t\tforecast_range_time.append(np.median(tt))\n\t\t\n\t\ttt = []\n\t\tfor t in T: \n\t\t\tt1 = time.time()\n\t\t\tinterface.engine.execute(\"select * from predict_range('ts_basic_%s', 'ts0',%s,%s, 'test_pindex', uq => true)\"%(ts,t_f, t_f+1000))\n\t\t\ttt.append(time.time() - t1)\n\t\tforecast_range_time_var.append(np.median(tt))\n\t\t\n\tdf = pd.DataFrame()\n\tdf['db_time'] = db_time\n\tdf['ts_time'] = ts_time\n\tdf['select_time'] = select_time\n\tdf['predict_time'] = predict_time\n\tdf['forecast_time'] = forecast_time\n\tdf['predict_time_var'] = predict_time_var\n\tdf['forecast_time_var'] = forecast_time_var\n\tdf['select_time_range'] = select_time_range\n\tdf['predict_range_time'] = predict_range_time\n\tdf['forecast_range_time'] = forecast_range_time\n\tdf['predict_range_time_var'] = predict_range_time_var\n\tdf['forecast_range_time_var'] = forecast_range_time_var\n\tdf['insert_time'] = insert_time\n\tdf['insert_time_2'] = insert_time_2\n\n\treturn df\n\n\ndef prediction_queries_latency_test():\n\tsetup = '''import numpy as np\nfrom tspdb.src.database_module.sql_imp import SqlImplementation\nfrom tspdb.src.pindex.predict import get_prediction_range, get_prediction\ninterface = SqlImplementation(driver=\"postgresql\", host=\"localhost\", database=\"querytime_test\",user=\"aalomar\",password=\"AAmit32lids\")\n\t'''\n\tstmt1 = '''interface.engine.execute(\"select * from predict('ts_basic_5', 'ts', 10, 'ts_basic5_pindex', uq => false)\")'''\n\tstmt2 = '''interface.engine.execute(\"select * from predict('ts_basic_5', 'ts', 10, 'ts_basic5_pindex', uq => true)\")'''\n\tstmt3 = '''interface.engine.execute(\"select * from predict_range('ts_basic_5', 'ts', 10,110, 'ts_basic5_pindex', uq => False)\")'''\n\t\n\t\n\tstmtA = '''interface.engine.execute(\"select ts from ts_basic_5 where time = 10\") '''\n\tstmtB = '''interface.engine.execute(\"select ts from ts_basic_5 where time >= 10 and time <= 110 \") '''\n\t\n\tprint ('(test1 pindex: point query )\t \timp query latency is %s that of SELECT ' %(timeit.timeit(setup = setup,stmt= stmt1, number =10000)/timeit.timeit(setup = setup,stmt= stmtA, number =10000)))\n\tprint ('(test2 pindex: point query with uq ) \timp query latency is %s that of SELECT ' %(timeit.timeit(setup = setup,stmt= stmt2, number =10000)/timeit.timeit(setup = setup,stmt= stmtA, number =10000)))\n\tprint ('(test3 pindex: range query 100 points )\t\timp query latency is %s that of SELECT ' %(timeit.timeit(setup = setup,stmt= stmt3, number =10000)/timeit.timeit(setup = setup,stmt= stmtB, number =10000)))\n\t\t\n\tstmt1 = '''interface.engine.execute(\"select * from predict('ts_basic_5', 'ts', 99995, 'ts_basic5_pindex', uq => false)\")'''\n\tstmt2 = '''interface.engine.execute(\"select * from predict('ts_basic_5', 'ts', 99995, 'ts_basic5_pindex', uq => true)\")'''\n\tstmt3 = '''interface.engine.execute(\"select * from predict_range('ts_basic_5', 'ts', 99995,99995+100, 'ts_basic5_pindex', uq => False)\")'''\n\t\n\tprint ('(test1 pindex: point query)\t \tForecast query latency is %s that of SELECT ' %(timeit.timeit(setup = setup,stmt= stmt1, number =1000)/timeit.timeit(setup = setup,stmt= stmtB, number =1000)))\n\tprint ('(test2 pindex: point query with uq) \tForecast query latency is %s that of SELECT ' %(timeit.timeit(setup = setup,stmt= stmt2, number =1000)/timeit.timeit(setup = setup,stmt= stmtA, number =1000)))\n\tprint ('(test3 pindex: range query 100 points)\t\tForecast query latency is %s that of SELECT ' %(timeit.timeit(setup = setup,stmt= stmt3, number =1000)/timeit.timeit(setup = setup,stmt= stmtB, number =1000)))\n\n"
] |
[
[
"numpy.square",
"numpy.random.normal",
"numpy.array",
"scipy.stats.norm.ppf",
"numpy.zeros",
"numpy.median",
"pandas.DataFrame",
"pandas.date_range",
"numpy.ones",
"numpy.mean",
"numpy.arange",
"sklearn.metrics.r2_score",
"numpy.random.random",
"pandas.read_csv"
]
] |
readthedocs-assistant/pangeo-pyinterp
|
[
"e9dc18445dce36638d5a90f64c8e2f1b53164f90",
"e9dc18445dce36638d5a90f64c8e2f1b53164f90"
] |
[
"src/pyinterp/tests/core/test_trivariate.py",
"src/pyinterp/grid.py"
] |
[
"# Copyright (c) 2022 CNES\n#\n# All rights reserved. Use of this source code is governed by a\n# BSD-style license that can be found in the LICENSE file.\nimport os\nimport pickle\nimport pytest\nimport netCDF4\ntry:\n import matplotlib.pyplot\n import matplotlib.colors\n HAVE_PLT = True\nexcept ImportError:\n HAVE_PLT = False\nimport numpy as np\nfrom ... import core\nfrom .. import grid3d_path, make_or_compare_reference\n\n\ndef plot(x, y, z, filename):\n figure = matplotlib.pyplot.figure(figsize=(15, 15), dpi=150)\n value = z.mean()\n std = z.std()\n normalize = matplotlib.colors.Normalize(vmin=value - 3 * std,\n vmax=value + 3 * std)\n axe = figure.add_subplot(2, 1, 1)\n axe.pcolormesh(x, y, z, cmap='jet', norm=normalize, shading='auto')\n figure.savefig(os.path.join(os.path.dirname(os.path.abspath(__file__)),\n filename),\n bbox_inches='tight',\n pad_inches=0.4)\n\n\ndef load_data(temporal_axis=False):\n with netCDF4.Dataset(grid3d_path()) as ds: # type: ignore\n z = np.flip(ds.variables['tcw'][:].T, axis=1)\n z[z.mask] = float(\"nan\")\n if temporal_axis:\n z_axis = core.TemporalAxis(\n netCDF4.num2date( # type: ignore\n ds.variables['time'][:],\n ds.variables['time'].units,\n only_use_cftime_datetimes=False,\n only_use_python_datetimes=True).astype(\"datetime64[h]\"))\n class_ = (core.TemporalGrid3DFloat64\n if temporal_axis else core.Grid3DFloat64)\n\n return core.TemporalGrid3DFloat64(\n core.Axis(ds.variables['longitude'][:], is_circle=True),\n core.Axis(np.flip(ds.variables['latitude'][:])), z_axis,\n z.data)\n return core.Grid3DFloat64(\n core.Axis(ds.variables['longitude'][:], is_circle=True),\n core.Axis(np.flip(ds.variables['latitude'][:])),\n core.Axis(ds.variables['time'][:]), z.data)\n\n\ndef test_grid3d_accessors():\n \"\"\"Test construction and accessors of the object\"\"\"\n grid = load_data()\n assert isinstance(grid.x, core.Axis)\n assert isinstance(grid.y, core.Axis)\n assert isinstance(grid.z, core.Axis)\n assert isinstance(grid.array, np.ndarray)\n\n\ndef test_grid3d_pickle():\n \"\"\"Serialization test\"\"\"\n grid = load_data()\n other = pickle.loads(pickle.dumps(grid))\n assert grid.x == other.x\n assert grid.y == other.y\n assert grid.z == other.z\n assert np.all(\n np.ma.fix_invalid(grid.array) == np.ma.fix_invalid(other.array))\n\n\ndef run_interpolator(interpolator, filename, visualize, dump):\n \"\"\"Testing an interpolation method.\"\"\"\n grid = load_data()\n lon = np.arange(-180, 180, 1 / 3.0) + 1 / 3.0\n lat = np.arange(-90, 90, 1 / 3.0) + 1 / 3.0\n time = 898500 + 3\n x, y, t = np.meshgrid(lon, lat, time, indexing=\"ij\")\n z0 = core.trivariate_float64(grid,\n x.ravel(),\n y.ravel(),\n t.ravel(),\n interpolator,\n num_threads=0)\n z1 = core.trivariate_float64(grid,\n x.ravel(),\n y.ravel(),\n t.ravel(),\n interpolator,\n num_threads=1)\n make_or_compare_reference(filename + \".npy\", z1, dump)\n shape = (len(lon), len(lat))\n z0 = np.ma.fix_invalid(z0)\n z1 = np.ma.fix_invalid(z1)\n assert np.all(z1 == z0)\n if HAVE_PLT and visualize:\n plot(x.reshape(shape), y.reshape(shape), z0.reshape(shape), filename)\n return z0\n\n\ndef test_trivariate_spline(pytestconfig):\n \"\"\"Testing of the spline interpolation\"\"\"\n grid = load_data()\n lon = np.arange(-180, 180, 1 / 3.0) + 1 / 3.0\n lat = np.arange(-80, 80, 1 / 3.0) + 1 / 3.0\n time = 898524 + 3\n x, y, t = np.meshgrid(lon, lat, time, indexing='ij')\n z0 = core.spline_float64(grid,\n x.ravel(),\n y.ravel(),\n t.ravel(),\n fitting_model=\"akima\",\n bounds_error=True,\n num_threads=0)\n z1 = core.spline_float64(grid,\n x.ravel(),\n y.ravel(),\n t.ravel(),\n fitting_model=\"akima\",\n bounds_error=True,\n num_threads=1)\n make_or_compare_reference(\"test_trivariate_spline.npy\", z1,\n pytestconfig.getoption(\"dump\"))\n shape = (len(lon), len(lat))\n z0 = np.ma.fix_invalid(z0)\n z1 = np.ma.fix_invalid(z1)\n assert np.all(z1 == z0)\n if HAVE_PLT and pytestconfig.getoption(\"visualize\"):\n plot(x.reshape(shape), y.reshape(shape), z0.reshape(shape),\n \"tcw_spline.png\")\n\n\ndef test_grid3d_bounds_error():\n \"\"\"Test of the detection on interpolation outside bounds\"\"\"\n grid = load_data()\n interpolator = core.Bilinear3D()\n lon = np.arange(-180, 180, 1 / 3.0) + 1 / 3.0\n lat = np.arange(-90, 90 + 1, 1 / 3.0) + 1 / 3.0\n time = 898500 + 3\n x, y, t = np.meshgrid(lon, lat, time, indexing=\"ij\")\n core.trivariate_float64(\n grid, # type: ignore\n x.ravel(),\n y.ravel(),\n t.ravel(),\n interpolator,\n num_threads=0)\n with pytest.raises(ValueError):\n core.trivariate_float64(\n grid, # type: ignore\n x.ravel(),\n y.ravel(),\n t.ravel(),\n interpolator,\n bounds_error=True,\n num_threads=0)\n\n\ndef test_grid3d_z_method(pytestconfig):\n \"\"\"Test of the interpolation method used on Z-axis\"\"\"\n dump = pytestconfig.getoption(\"dump\")\n grid = load_data(temporal_axis=True)\n interpolator = core.TemporalBilinear3D()\n lon = np.arange(-180, 180, 1 / 3.0) + 1 / 3.0\n lat = np.arange(-90, 90 + 1, 1 / 3.0) + 1 / 3.0\n time = np.array([\n netCDF4.num2date( # type: ignore\n 898500 + 3,\n \"hours since 1900-01-01 00:00:0.0\",\n only_use_cftime_datetimes=False,\n only_use_python_datetimes=True)\n ]).astype(\"datetime64[h]\").astype(\"int64\")\n x, y, t = np.meshgrid(lon, lat, time, indexing=\"ij\")\n z0 = core.trivariate_float64(\n grid, # type: ignore\n x.ravel(),\n y.ravel(),\n t.ravel(),\n interpolator,\n num_threads=0)\n z1 = core.trivariate_float64(\n grid, # type: ignore\n x.ravel(),\n y.ravel(),\n t.ravel(),\n interpolator,\n z_method=\"linear\",\n num_threads=0)\n make_or_compare_reference(\"test_grid3d_z_method_linear.npy\", z1, dump)\n z0 = np.ma.fix_invalid(z0)\n z1 = np.ma.fix_invalid(z1)\n assert np.all(z0 == z1)\n z1 = core.trivariate_float64(\n grid, # type: ignore\n x.ravel(),\n y.ravel(),\n t.ravel(),\n interpolator,\n z_method=\"nearest\",\n num_threads=0)\n make_or_compare_reference(\"test_grid3d_z_method_nearest.npy\", z1, dump)\n z1 = np.ma.fix_invalid(z1)\n assert np.all(z0 != z1)\n with pytest.raises(ValueError):\n core.trivariate_float64(\n grid, # type: ignore\n x.ravel(),\n y.ravel(),\n t.ravel(),\n interpolator,\n z_method=\"NEAREST\",\n num_threads=0)\n\n\ndef test_grid3d_interpolator(pytestconfig):\n \"\"\"Testing of different interpolation methods\"\"\"\n visualize = pytestconfig.getoption(\"visualize\")\n dump = pytestconfig.getoption(\"dump\")\n a = run_interpolator(core.Nearest3D(), \"tcw_trivariate_nearest\", visualize,\n dump)\n b = run_interpolator(core.Bilinear3D(), \"tcw_trivariate_bilinear\",\n visualize, dump)\n c = run_interpolator(core.InverseDistanceWeighting3D(),\n \"tcw_trivariate_idw\", visualize, dump)\n assert (a - b).std() != 0\n assert (a - c).std() != 0\n assert (b - c).std() != 0\n",
"# Copyright (c) 2022 CNES\n#\n# All rights reserved. Use of this source code is governed by a\n# BSD-style license that can be found in the LICENSE file.\n\"\"\"\nRegular grids\n=============\n\"\"\"\nfrom typing import Optional, Union\nimport numpy as np\nfrom . import core\nfrom . import interface\n\n\nclass Grid2D:\n \"\"\"2D Cartesian Grid.\n \"\"\"\n #: The number of grid dimensions handled by this object\n _DIMENSIONS = 2\n\n def __init__(self, *args, increasing_axes: Optional[str] = None):\n \"\"\"\n Initialize a new 2D Cartesian Grid.\n\n Args:\n x (pyinterp.Axis): X-Axis.\n y (pyinterp.Axis): Y-Axis.\n array (numpy.ndarray): Discrete representation of a continuous\n function on a uniform 2-dimensional grid.\n increasing_axes ({'inplace', 'copy'}, optional): Optional string\n indicating how to ensure that the grid axes are increasing. If\n axes are decreasing, the axes and grid provided will be flipped\n in place or copied before being flipped. By default, the\n decreasing axes are not modified.\n\n Examples:\n\n >>> import numpy as np\n >>> import pyinterp\n >>> x_axis = pyinterp.Axis(np.arange(-180.0, 180.0, 1.0),\n ... is_circle=True)\n >>> y_axis = pyinterp.Axis(np.arange(-80.0, 80.0, 1.0),\n ... is_circle=False)\n >>> array = np.zeros((len(x_axis), len(y_axis)))\n >>> grid = pyinterp.Grid2D(x_axis, y_axis, array)\n >>> grid\n <pyinterp.grid.Grid2D>\n array([[0., 0., 0., ..., 0., 0., 0.],\n [0., 0., 0., ..., 0., 0., 0.],\n [0., 0., 0., ..., 0., 0., 0.],\n ...,\n [0., 0., 0., ..., 0., 0., 0.],\n [0., 0., 0., ..., 0., 0., 0.],\n [0., 0., 0., ..., 0., 0., 0.]])\n Axis:\n * x: <pyinterp.axis.Axis>\n min_value: -180.0\n max_value: 179.0\n step: 1.0\n is_circle: True\n * y: <pyinterp.axis.Axis>\n min_value: -80.0\n max_value: 79.0\n step: 1.0\n is_circle: False\n \"\"\"\n prefix = \"\"\n for idx, item in enumerate(args):\n if isinstance(item, core.TemporalAxis):\n prefix = \"Temporal\"\n break\n _class = f\"{prefix}Grid{self._DIMENSIONS}D\" + \\\n interface._core_class_suffix(args[-1], handle_integer=True)\n if increasing_axes is not None:\n if increasing_axes not in ['inplace', 'copy']:\n raise ValueError(\"increasing_axes \"\n f\"{increasing_axes!r} is not defined\")\n inplace = increasing_axes == 'inplace'\n # Tuple does not support item assignment\n args = list(args)\n for idx, item in enumerate(args):\n if isinstance(item,\n (core.Axis,\n core.TemporalAxis)) and not item.is_ascending():\n args[idx] = item.flip(inplace=inplace)\n args[-1] = np.flip(args[-1], axis=idx)\n self._instance = getattr(core, _class)(*args)\n self._prefix = prefix\n\n def __repr__(self):\n \"\"\"Called by the ``repr()`` built-in function to compute the string\n representation of this instance.\n \"\"\"\n pad = lambda s, n: \"\\n\".join([(\" \" * n if ix else \"\") + line for ix,\n line in enumerate(s.split(\"\\n\"))])\n result = [\n f\"<{self.__module__}.{self.__class__.__name__}>\",\n repr(self.array),\n ]\n result.append(\"Axis:\")\n for item in dir(self):\n attr = getattr(self, item)\n if isinstance(attr, (core.Axis, core.TemporalAxis)):\n prefix = f\"* {item}: \"\n result.append(f\" {prefix}{pad(repr(attr), len(prefix))}\")\n return \"\\n\".join(result)\n\n @property\n def x(self) -> core.Axis:\n \"\"\"Gets the X-Axis handled by this instance.\n\n Returns:\n pyinterp.Axis: X-Axis.\n \"\"\"\n return self._instance.x\n\n @property\n def y(self) -> core.Axis:\n \"\"\"Gets the Y-Axis handled by this instance\n\n Returns:\n pyinterp.Axis: Y-Axis.\n \"\"\"\n return self._instance.y\n\n @property\n def array(self) -> np.ndarray:\n \"\"\"Gets the values handled by this instance.\n\n Returns:\n numpy.ndarray: values.\n \"\"\"\n return self._instance.array\n\n\nclass Grid3D(Grid2D):\n \"\"\"3D Cartesian Grid.\n \"\"\"\n _DIMENSIONS = 3\n\n def __init__(self, *args, increasing_axes=None):\n \"\"\"\n Initialize a new 3D Cartesian Grid.\n\n Args:\n x (pyinterp.Axis): X-Axis.\n y (pyinterp.Axis): Y-Axis.\n z (pyinterp.Axis, pyinterp.TemporalAxis): Z-Axis.\n array (numpy.ndarray): Discrete representation of a continuous\n function on a uniform 3-dimensional grid.\n increasing_axes (bool, optional): Ensure that the axes of the grid\n are increasing. If this is not the case, the axes and grid\n provided will be flipped. Default to False.\n\n .. note::\n\n If the Z axis is a :py:class:`temporal axis\n <pyinterp.TemporalAxis>`, the grid will handle this axis during\n interpolations as a time axis.\n\n Examples:\n\n >>> import numpy as np\n >>> import pyinterp\n >>> x_axis = pyinterp.Axis(np.arange(-180.0, 180.0, 1.0),\n ... is_circle=True)\n >>> y_axis = pyinterp.Axis(np.arange(-80.0, 80.0, 1.0),\n ... is_circle=False)\n >>> z_axis = pyinterp.TemporalAxis(\n ... np.array(['2000-01-01'], dtype=\"datetime64[s]\"))\n >>> array = np.zeros((len(x_axis), len(y_axis), len(z_axis)))\n >>> grid = pyinterp.Grid3D(x_axis, y_axis, z_axis, array)\n \"\"\"\n super().__init__(*args, increasing_axes=increasing_axes)\n\n @property\n def z(self) -> Union[core.Axis, core.TemporalAxis]:\n \"\"\"\n Gets the Z-Axis handled by this instance.\n\n Returns:\n pyinterp.Axis, pyinterp.TemporalAxis: Z-Axis.\n \"\"\"\n return self._instance.z\n\n\nclass Grid4D(Grid3D):\n \"\"\"4D Cartesian Grid.\n \"\"\"\n _DIMENSIONS = 4\n\n def __init__(self, *args, increasing_axes=None):\n \"\"\"\n Initialize a new 4D Cartesian Grid.\n\n Args:\n x (pyinterp.Axis): X-Axis.\n y (pyinterp.Axis): Y-Axis.\n z (pyinterp.Axis, pyinterp.TemporalAxis): Z-Axis.\n u (pyinterp.Axis): U-Axis.\n array (numpy.ndarray): Discrete representation of a continuous\n function on a uniform 4-dimensional grid.\n increasing_axes (bool, optional): Ensure that the axes of the grid\n are increasing. If this is not the case, the axes and grid\n provided will be flipped. Default to False.\n\n .. note::\n\n If the Z axis is a temporal axis, the grid will handle this axis\n during interpolations as a time axis.\n \"\"\"\n super().__init__(*args, increasing_axes=increasing_axes)\n\n @property\n def u(self) -> core.Axis:\n \"\"\"Gets the U-Axis handled by this instance.\n\n Returns:\n pyinterp.Axis: U-Axis.\n \"\"\"\n return self._instance.u\n\n\ndef _core_variate_interpolator(instance: object, interpolator: str, **kwargs):\n \"\"\"Obtain the interpolator from the string provided.\"\"\"\n if isinstance(instance, Grid2D):\n dimensions = instance._DIMENSIONS\n # 4D interpolation uses the 3D interpolator\n if dimensions > 3:\n dimensions -= 1\n else:\n raise TypeError(\"instance is not an object handling a grid.\")\n\n prefix = instance._prefix\n\n if interpolator == \"bilinear\":\n return getattr(core, f\"{prefix}Bilinear{dimensions}D\")(**kwargs)\n if interpolator == \"nearest\":\n return getattr(core, f\"{prefix}Nearest{dimensions}D\")(**kwargs)\n if interpolator == \"inverse_distance_weighting\":\n return getattr(\n core, f\"{prefix}InverseDistanceWeighting{dimensions}D\")(**kwargs)\n\n raise ValueError(f\"interpolator {interpolator!r} is not defined\")\n"
] |
[
[
"numpy.ma.fix_invalid",
"numpy.arange",
"numpy.all",
"numpy.meshgrid",
"numpy.flip"
],
[
"numpy.flip"
]
] |
johnnykoo84/DS-Unit-3-Sprint-2-SQL-and-Databases
|
[
"484de1902b3785b68a0f598ca75e32d67e6ba09a"
] |
[
"module2-sql-for-analysis/insert_titanic.py"
] |
[
"import os\nimport pandas as pd\nimport psycopg2\nfrom psycopg2 import extras\nfrom dotenv import load_dotenv\nimport numpy as np\nload_dotenv()\nprint(__file__)\npsycopg2.extensions.register_adapter(np.int64, psycopg2._psycopg.AsIs)\n\n# load csv to dataframe\nCSV_FILE_PATH = os.path.join(os.path.dirname(__file__), 'titanic.csv')\ndf = pd.read_csv(CSV_FILE_PATH)\n# print(df.head())\n# print(df.columns)\n# print(df.values)\nprint('df.dtypes\\n', df.dtypes)\n# Connect to ElephantSQL-hosted PostgreSQL\nconn = psycopg2.connect(\n dbname=os.getenv(\"dbname\"),\n user=os.getenv(\"user\"),\n password=os.getenv(\"password\"),\n host=os.getenv(\"host\")\n)\n# A \"cursor\", a structure to iterate over db records to perform queries\ncur = conn.cursor()\n\n# Drop the table if exist\ncur.execute('DROP TABLE IF EXISTS Titanic;')\n\n# CREATE TABLE query\nquery_create = \"\"\"CREATE TABLE Titanic (\n Survived INT,\n Pclass INT,\n Name varchar(120),\n Sex varchar(10),\n Age INT,\n SiblingsSpouses INT,\n ParentsChildren INT,\n Fare INT);\n\"\"\"\ncur.execute(query_create)\n\n# test\n\n# query = 'INSERT INTO Titanic VALUES (0, 3, \\'Mr. Owen\\', \\'male\\', 22.0, 1, 0, 7.25);'\n# cur.execute(query)\n# cur.execute('SELECT * FROM Titanic')\n# print('first fetch', cur.fetchall())\n\n# this is a solution from Mike\nlist_of_tuples = list(df.to_records(index=False))\nins_query = 'INSERT INTO Titanic (Survived, Pclass, Name, Sex, Age, SiblingsSpouses, ParentsChildren, Fare) VALUES %s;'\nextras.execute_values(cur, ins_query, list_of_tuples)\n\n# this was my initial code but not working\n# for row in df.values:\n# print('######')\n# print(type(row))\n# print(row)\n# cur.execute(\"INSERT INTO Titanic (Survived, Pclass, Name, Sex, Age, SiblingsSpouses, ParentsChildren, Fare) VALUES %s;\", tuple(row))\n\nconn.commit()\n\ncur.execute('SELECT * FROM Titanic')\nprint('second fetch', cur.fetchall())\n"
] |
[
[
"pandas.read_csv"
]
] |
rougier/VSOM
|
[
"78e6eb924b5f89a0e6f42eb6bbe7971473a9abaa"
] |
[
"attic/vsom.py"
] |
[
"# -----------------------------------------------------------------------------\n# VSOM (Voronoidal Self Organized Map)\n# Copyright (c) 2019 Nicolas P. Rougier\n#\n# Distributed under the terms of the BSD License.\n# -----------------------------------------------------------------------------\nimport sys\nimport tqdm\nimport numpy as np\nimport scipy.spatial\nfrom math import sqrt, ceil, floor, pi, cos, sin\n\nimport scipy.spatial\nimport networkx as nx\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport matplotlib.patheffects as path_effects\nfrom matplotlib.offsetbox import OffsetImage, AnnotationBbox\nfrom matplotlib.collections import LineCollection, PolyCollection\n\n\n\n# http://stackoverflow.com/questions/28665491/...\n# ...getting-a-bounded-polygon-coordinates-from-voronoi-cells\ndef in_box(points, bbox):\n return np.logical_and(\n np.logical_and(bbox[0] <= points[:, 0], points[:, 0] <= bbox[1]),\n np.logical_and(bbox[2] <= points[:, 1], points[:, 1] <= bbox[3]))\n\n\ndef voronoi(points, bbox):\n # See http://stackoverflow.com/questions/28665491/...\n # ...getting-a-bounded-polygon-coordinates-from-voronoi-cells\n # See also https://gist.github.com/pv/8036995\n \n # Select points inside the bounding box\n i = in_box(points, bbox)\n\n # Mirror points\n points_center = points[i, :]\n points_left = np.copy(points_center)\n points_left[:, 0] = bbox[0] - (points_left[:, 0] - bbox[0])\n points_right = np.copy(points_center)\n points_right[:, 0] = bbox[1] + (bbox[1] - points_right[:, 0])\n points_down = np.copy(points_center)\n points_down[:, 1] = bbox[2] - (points_down[:, 1] - bbox[2])\n points_up = np.copy(points_center)\n points_up[:, 1] = bbox[3] + (bbox[3] - points_up[:, 1])\n points = np.append(points_center,\n np.append(np.append(points_left, points_right, axis=0),\n np.append(points_down, points_up, axis=0),\n axis=0), axis=0)\n # Compute Voronoi\n vor = scipy.spatial.Voronoi(points)\n epsilon = sys.float_info.epsilon\n\n # Filter regions\n regions = []\n for region in vor.regions:\n flag = True\n for index in region:\n if index == -1:\n flag = False\n break\n else:\n x = vor.vertices[index, 0]\n y = vor.vertices[index, 1]\n if not(bbox[0]-epsilon <= x <= bbox[1]+epsilon and\n bbox[2]-epsilon <= y <= bbox[3]+epsilon):\n flag = False\n break\n if region != [] and flag:\n regions.append(region)\n vor.filtered_points = points_center\n vor.filtered_regions = regions\n return vor\n\n\ndef centroid(V):\n \"\"\"\n Given an ordered set of vertices V describing a polygon,\n returns the uniform surface centroid.\n\n See http://paulbourke.net/geometry/polygonmesh/\n \"\"\"\n A = 0\n Cx = 0\n Cy = 0\n for i in range(len(V)-1):\n s = (V[i, 0]*V[i+1, 1] - V[i+1, 0]*V[i, 1])\n A += s\n Cx += (V[i, 0] + V[i+1, 0]) * s\n Cy += (V[i, 1] + V[i+1, 1]) * s\n Cx /= 3*A\n Cy /= 3*A\n return [Cx, Cy]\n\n\ndef blue_noise(shape, radius, k=30, seed=None):\n \"\"\"\n Generate blue noise over a two-dimensional rectangle of size (width,height)\n\n Parameters\n ----------\n\n shape : tuple\n Two-dimensional domain (width x height) \n radius : float\n Minimum distance between samples\n k : int, optional\n Limit of samples to choose before rejection (typically k = 30)\n seed : int, optional\n If provided, this will set the random seed before generating noise,\n for valid pseudo-random comparisons.\n\n References\n ----------\n\n .. [1] Fast Poisson Disk Sampling in Arbitrary Dimensions, Robert Bridson,\n Siggraph, 2007. :DOI:`10.1145/1278780.1278807`\n \"\"\"\n\n def sqdist(a, b):\n \"\"\" Squared Euclidean distance \"\"\"\n dx, dy = a[0] - b[0], a[1] - b[1]\n return dx * dx + dy * dy\n\n def grid_coords(p):\n \"\"\" Return index of cell grid corresponding to p \"\"\"\n return int(floor(p[0] / cellsize)), int(floor(p[1] / cellsize))\n\n def fits(p, radius):\n \"\"\" Check whether p can be added to the queue \"\"\"\n\n radius2 = radius*radius\n gx, gy = grid_coords(p)\n for x in range(max(gx - 2, 0), min(gx + 3, grid_width)):\n for y in range(max(gy - 2, 0), min(gy + 3, grid_height)):\n g = grid[x + y * grid_width]\n if g is None:\n continue\n if sqdist(p, g) <= radius2:\n return False\n return True\n\n # When given a seed, we use a private random generator in order to not\n # disturb the default global random generator\n if seed is not None:\n from numpy.random.mtrand import RandomState\n rng = RandomState(seed=seed)\n else:\n rng = np.random\n \n width, height = shape\n cellsize = radius / sqrt(2)\n grid_width = int(ceil(width / cellsize))\n grid_height = int(ceil(height / cellsize))\n grid = [None] * (grid_width * grid_height)\n\n p = rng.uniform(0, shape, 2)\n queue = [p]\n grid_x, grid_y = grid_coords(p)\n grid[grid_x + grid_y * grid_width] = p\n\n while queue:\n qi = rng.randint(len(queue))\n qx, qy = queue[qi]\n queue[qi] = queue[-1]\n queue.pop()\n for _ in range(k):\n theta = rng.uniform(0,2*pi)\n r = radius * np.sqrt(rng.uniform(1, 4))\n p = qx + r * cos(theta), qy + r * sin(theta)\n if not (0 <= p[0] < width and 0 <= p[1] < height) or not fits(p, radius):\n continue\n queue.append(p)\n gx, gy = grid_coords(p)\n grid[gx + gy * grid_width] = p\n\n return np.array([p for p in grid if p is not None])\n\n\n\n\nclass VSOM2:\n \"\"\" Self Organizing Map \"\"\"\n\n def __init__(self, topology=\"regular\", n=1024, n_neighbour=2):\n \"\"\"\n Initialize SOM\n\n type: string\n \"regular\" or \"random\"\n n : int\n number of neurons\n ndim: int\n dimension of data to be fed to the SOM\n \"\"\"\n\n self.topology = topology\n self.n_neighbour = n_neighbour\n \n if self.topology == \"regular\":\n n = int(np.ceil(np.sqrt(n)))\n X, Y = np.meshgrid(np.linspace(0, 1, n+2, endpoint=True)[1:-1],\n np.linspace(0, 1, n+2, endpoint=True)[1:-1])\n P = np.c_[X.ravel(), Y.ravel()]\n D = scipy.spatial.distance.cdist(P,P)\n self.positions = P\n self.distances = D / D.max()\n self.voronoi = voronoi(P, bbox=[0, 1, 0, 1])\n self.edges = np.zeros((n*n*2, 2), dtype=int)\n index = 0\n for i in range(n):\n for j in range(n-1):\n source, target = i*n+j, i*n+j+1\n self.edges[index] = source, target\n index += 1\n source, target = j*n+i, (j+1)*n+i\n self.edges[index] = source, target\n index += 1\n \n else:\n radius = np.sqrt(2/(n*np.pi))\n P = blue_noise((1,1), radius=radius)\n self.voronoi = voronoi(P, bbox=[0, 1, 0, 1])\n \n # for i in range(10):\n # V = voronoi(P, bbox=[0,1,0,1])\n # C = []\n # for region in V.filtered_regions:\n # vertices = V.vertices[region + [region[0]], :]\n # C.append(centroid(vertices))\n # P = np.array(C)\n \n self.positions = P\n self.voronoi = V\n D = scipy.spatial.distance.cdist(P,P)\n sources = np.repeat(np.arange(len(P)),n_neighbour)\n sources = sources.reshape(len(P),n_neighbour)\n targets = np.argsort(D,axis=1)[:,1:n_neighbour+1]\n self.edges = np.c_[sources.ravel(), targets.ravel()]\n C = np.zeros(D.shape, dtype=int)\n C[sources,targets] = 1\n lengths = nx.floyd_warshall_numpy(nx.Graph(C))\n self.distances = np.array(lengths).astype(int)\n self.distances = self.distances/self.distances.max()\n \n\n def __len__(self):\n \"\"\" x.__len__() <==> len(x) \"\"\"\n\n return len(self.positions)\n \n \n def learn(self, samples, n=10000,\n sigma=(0.50, 0.01), lrate=(0.50, 0.01), labels=None):\n \"\"\" Learn samples \"\"\"\n\n t = np.linspace(0, 1, n)\n\n # We will reshape the final codebook to keep samples shape\n shape = [len(self)] + list(samples.shape[1:])\n \n samples = samples.reshape(len(samples), -1)\n self.codebook = np.zeros((len(self), samples.shape[-1]))\n self.labels = np.zeros(len(self))\n\n lrate = lrate[0]*(lrate[1]/lrate[0])**t\n sigma = sigma[0]*(sigma[1]/sigma[0])**t\n I = np.random.randint(0, len(samples), n)\n samples = samples[I]\n if labels is not None:\n labels = labels[I]\n \n for i in tqdm.trange(n):\n # Get random sample\n data = samples[i]\n\n # Get index of nearest node (minimum distance)\n winner = np.argmin(((self.codebook - data)**2).sum(axis=-1))\n\n # Gaussian centered on winner\n G = np.exp(-self.distances[winner]**2/sigma[i]**2)\n\n # Move nodes towards sample according to Gaussian \n self.codebook -= lrate[i]*G[...,np.newaxis]*(self.codebook - data)\n\n if labels is not None:\n self.labels -= lrate[i]*G*(self.labels-labels[i])\n # self.labels[winner] = labels[i]\n\n self.codebook = self.codebook.reshape(shape)\n\n\n def test(self, samples, labels=None):\n \"\"\" Learn samples \"\"\"\n\n samples = samples.reshape(len(samples), -1)\n codebook = self.codebook.reshape((len(self), -1))\n error = 0\n for i in tqdm.trange(len(samples)):\n sample = samples[i]\n winner = np.argmin(((codebook - sample)**2).sum(axis=-1))\n error += ((codebook[i] - sample)**2).sum()\n error /= len(samples)\n return error\n\n \n # samples = samples.reshape(len(samples), -1)\n # codebook = self.codebook.reshape((len(self), -1))\n # #self.labels = np.zeros(len(self))\n # s = []\n # z = 0\n # for i in tqdm.trange(len(samples)):\n # sample = samples[i]\n # label = labels[i]\n # winner = np.argmin(((codebook - sample)**2).sum(axis=-1))\n # s.append(np.abs(label - self.labels[winner]))\n\n # if label == int((self.labels[winner])):\n # z += 1\n \n # print(np.mean(s))\n # print(z/len(samples))\n \n\n\n def plot_activation(self, ax, sample, cmap='plasma'):\n\n codebook = self.codebook.reshape(len(self), -1)\n \n D = -np.sqrt(((codebook - sample.ravel())**2).sum(axis=-1))\n P = self.positions\n \n if self.topology == \"random\":\n V = self.voronoi\n cmap = matplotlib.cm.get_cmap(cmap)\n norm = matplotlib.colors.Normalize(vmin=D.min(), vmax=D.max())\n segments = []\n for region in V.filtered_regions:\n segments.append(V.vertices[region + [region[0]], :])\n collection = PolyCollection(segments, linewidth=1.0,\n edgecolors=cmap(norm(D)),\n facecolors=cmap(norm(D)))\n ax.add_collection(collection)\n\n from scipy.interpolate import griddata\n X, Y = np.linspace(0, 1, 512), np.linspace(0, 1, 512)\n Z = griddata(P, D, (X[None,:], Y[:,None]), method='nearest')\n ax.contour(X, Y, Z, 8, linewidths=0.5, colors='k', alpha=0.75)\n\n else: # regular\n n = int(np.ceil(np.sqrt(len(self))))\n Z = D.reshape(n,n)\n X, Y = np.linspace(0, 1, n), np.linspace(0, 1, n)\n ax.imshow(Z, cmap=cmap, interpolation='nearest', extent=[0,1,0,1],\n origin=\"lower\")\n ax.contour(X, Y, Z, 8, linewidths=0.5, colors='k', alpha=0.75)\n\n if len(sample.shape) == 2:\n rows,cols = sample.shape\n image = np.zeros((rows,cols,4))\n image[:,:,0] = image[:,:,1] = image[:,:,2] = 0\n image[:,:,3] = sample\n image = OffsetImage(image, zoom=1.5, zorder=20,\n interpolation=\"nearest\")\n box = AnnotationBbox(image, (0.9,0.9), frameon=True)\n ax.add_artist(box)\n\n ax.set_xlim(0,1), ax.set_ylim(0,1)\n ax.set_xticks([]), ax.set_yticks([])\n\n\n\n def plot_network(self, ax):\n size = 50 * 1000/len(self)\n P,V,E = self.positions, self.voronoi, self.edges\n ax.scatter(P[:,0], P[:,1], s=size,\n edgecolor=\"k\", facecolor=\"w\", linewidth=1.)\n segments = np.zeros((len(E), 2, 2))\n for i in range(len(E)):\n segments[i] = P[E[i,0]], P[E[i,1]]\n collection = LineCollection(segments, color=\"k\", zorder=-10, lw=1.)\n ax.add_collection(collection)\n\n segments = []\n for region in V.filtered_regions:\n segments.append(V.vertices[region + [region[0]], :])\n collection = LineCollection(segments, color=\"k\", linewidth=0.5,\n zorder=-20, alpha=0.25)\n ax.add_collection(collection)\n ax.set_xlim(0,1), ax.set_ylim(0,1)\n ax.set_xticks([]), ax.set_yticks([])\n\n\n def plot_weights(self, ax, cmap='magma', samples=None):\n P,V,E = self.positions, self.voronoi, self.edges\n\n # Display weights as localized images\n if len(self.codebook.shape) == 3:\n rows,cols = self.codebook.shape[1:]\n segments = []\n for region in V.filtered_regions:\n segments.append(V.vertices[region + [region[0]], :])\n collection = PolyCollection(segments, linewidth=0.25, alpha=1.0,\n edgecolors=\"k\", facecolors=\"w\")\n ax.add_collection(collection)\n\n \n for position, data in zip(P, self.codebook):\n image = np.zeros((rows,cols,4))\n image[:,:,3] = data.reshape(rows,cols)\n image = OffsetImage(image,\n zoom=0.5, zorder=20, interpolation=\"nearest\")\n box = AnnotationBbox(image, position, frameon=False)\n ax.add_artist(box)\n\n ax.set_xlim(0,1), ax.set_ylim(0,1)\n ax.set_xticks([]), ax.set_yticks([])\n return\n \n codebook = self.codebook.reshape(len(self), -1)\n\n # Display weights as a mesh in data space\n if codebook.shape[-1] == 2:\n size = 50 * 1000/len(self)\n X, Y = codebook[:,0], codebook[:,1]\n ax.scatter(X, Y, s=size, edgecolor=\"w\", facecolor=\"k\", linewidth=1.0)\n ax.scatter(samples[:,0], samples[:,1], s=5,\n edgecolor=\"None\", facecolor=\"blue\",\n alpha=0.25, zorder=-30)\n \n segments = np.zeros((len(self.edges), 2, 2))\n for i in range(len(self.edges)): \n segments[i] = codebook[self.edges[i,0]], codebook[self.edges[i,1]]\n collection = LineCollection(segments, linewidth=0.75,\n color='black', zorder=-10, alpha=1.0)\n ax.add_collection(collection)\n ax.set_xlim(-1,1), ax.set_ylim(-1,1)\n ax.set_xticks([]), ax.set_yticks([])\n return\n\n \n if self.topology == \"random\":\n # Display weights as voronoi cells + cmap\n if codebook.shape[-1] == 1:\n cmap = matplotlib.cm.get_cmap(cmap)\n norm = matplotlib.colors.Normalize(vmin=0, vmax=1)\n facecolors = edgecolors = cmap(norm(self.codebook.ravel()))\n # Display weights as colored voronoi cells\n elif codebook.shape[-1] == 3:\n facecolors = edgecolors = codebook\n segments = []\n for region in V.filtered_regions:\n segments.append(V.vertices[region + [region[0]], :])\n collection = PolyCollection(segments, linewidth=1.0,\n edgecolors = edgecolors, facecolors = facecolors)\n ax.add_collection(collection)\n else:\n n = int(np.ceil(np.sqrt(len(self))))\n # Display weights on a regular grid + cmap\n if codebook.shape[-1] == 1:\n ax.imshow(codebook.reshape(n,n), cmap=cmap, origin=\"lower\",\n interpolation='nearest', extent=[0, 1, 0, 1])\n # Display weights on a colored regular grid\n elif self.codebook.shape[-1] == 3:\n ax.imshow(codebook.reshape(n,n,3), origin=\"lower\",\n interpolation='nearest', extent=[0, 1, 0, 1])\n\n ax.set_xlim(0,1), ax.set_ylim(0,1)\n ax.set_xticks([]), ax.set_yticks([])\n\n \n def plot_letter(self, ax, letter):\n text = ax.text(0.05, 0.05, letter, zorder=20,\n fontsize=32, fontweight=\"bold\", transform=ax.transAxes)\n text.set_path_effects(\n [path_effects.Stroke(linewidth=2, foreground='white'),\n path_effects.Normal()])\n\n\n \nclass VSOM:\n \"\"\" Randomized Self Organizing Map \"\"\"\n\n def __init__(self, shape, distance):\n ''' Initialize som '''\n\n self.codebook = np.random.uniform(0, 1, shape)\n self.labels = np.random.uniform(0, 1, len(self.codebook))\n self.distance = distance / distance.max()\n\n \n def learn(self, samples, n=10000, sigma=(0.25, 0.01), lrate=(0.5, 0.01)):\n \"\"\" Learn samples \"\"\"\n\n t = np.linspace(0, 1, n)\n lrate = lrate[0]*(lrate[1]/lrate[0])**t\n sigma = sigma[0]*(sigma[1]/sigma[0])**t\n I = np.random.randint(0, len(samples), n)\n samples = samples[I]\n\n for i in tqdm.trange(n):\n # Get random sample\n data = samples[i]\n\n # Get index of nearest node (minimum distance)\n winner = np.argmin(((self.codebook - data)**2).sum(axis=-1))\n\n # Gaussian centered on winner\n G = np.exp(-self.distance[winner]**2/sigma[i]**2)\n\n # Move nodes towards sample according to Gaussian \n self.codebook -= lrate[i]*G[...,np.newaxis]*(self.codebook - data)\n\n\n"
] |
[
[
"numpy.copy",
"numpy.exp",
"numpy.random.mtrand.RandomState",
"scipy.interpolate.griddata",
"matplotlib.offsetbox.OffsetImage",
"numpy.logical_and",
"numpy.sqrt",
"numpy.append",
"numpy.array",
"numpy.zeros",
"matplotlib.cm.get_cmap",
"matplotlib.collections.LineCollection",
"numpy.argsort",
"matplotlib.collections.PolyCollection",
"numpy.random.uniform",
"matplotlib.colors.Normalize",
"matplotlib.patheffects.Normal",
"numpy.linspace",
"matplotlib.offsetbox.AnnotationBbox",
"matplotlib.patheffects.Stroke"
]
] |
fanyizhe/aws-reserved-instance-expiration-notification
|
[
"018c37f7d547937f6390b5184756d199338ba7d6"
] |
[
"src/ri_expiration.py"
] |
[
"# Copyright <2019> Amazon.com, Inc. or its affiliates. All Rights Reserved.\n# SPDX-License-Identifier: Apache-2.0\n\nimport json\nimport boto3\nfrom botocore.exceptions import ClientError\nfrom multiprocessing import Process\nfrom dateutil import relativedelta\nfrom datetime import date, datetime, timedelta\nimport numpy as np\nimport pandas as pd\nimport os\n\nfrom email.mime.text import MIMEText\nfrom email.mime.application import MIMEApplication\nfrom email.mime.multipart import MIMEMultipart\n\nTARGET_REGION = 'ap-northeast-2'\nSES_REGION = 'us-east-1'\nSENDER = \"blah <your_email@example.com>\"\n\ndef send_email(info):\n RECIPIENT = info['email']\n attachments = info['attach']\n BODY_HTML = info['msg']\n\n message = MIMEMultipart()\n message['Subject'] = 'Amazon RI Expiration Notification'\n message['From'] = SENDER\n message['To'] = RECIPIENT\n destinations = []\n destinations.append(RECIPIENT)\n\n # message body\n part = MIMEText(BODY_HTML, 'html')\n message.attach(part)\n\n # attachment\n for attachment in attachments:\n with open(attachment, 'rb') as f:\n part = MIMEApplication(f.read())\n part.add_header('Content-Disposition', 'attachment', filename=os.path.basename(attachment))\n message.attach(part)\n\n client = boto3.client('ses', region_name=SES_REGION)\n response = client.send_raw_email(\n Source=message['From'],\n Destinations=destinations,\n RawMessage={\n 'Data': message.as_string()\n }\n )\n\n\ndef getExpRIList(response: boto3.resources.response, response_name, filter_name, filter_value, select_column=[]):\n if len(response[response_name]) > 0:\n print(\"Exist \" + response_name)\n\n next_month = np.datetime64(datetime.utcnow() + relativedelta.relativedelta(days=31))\n ri_list = list(map(lambda a: a.values(), filter(lambda a: a[filter_name] == filter_value, response[response_name])))\n head = response[response_name][0].keys()\n df = pd.DataFrame(ri_list, columns=head)\n df['StartTime'] = pd.to_datetime(df['StartTime']).dt.tz_convert(None)\n df['End'] = df['StartTime'] + pd.to_timedelta(df['Duration'], 's')\n will_expire = df[df['End'] <= next_month]\n filtered_list = will_expire[select_column].values.tolist()\n return filtered_list, will_expire[select_column].columns.to_list(), df\n\n\ndef to_excel(df, filename, condition):\n writer = pd.ExcelWriter(filename)\n row_style = lambda row: pd.Series('background-color: {}'.format('yellow' if condition(row) else 'green'), row.index)\n df.style.apply(row_style, axis=1).to_excel(writer, )\n writer.save()\n writer.close()\n\n\ndef makeMessage():\n # df\n next_month = np.datetime64(datetime.utcnow() + relativedelta.relativedelta(days=31))\n\n # ec2\n ec2_client = boto3.client('ec2', region_name=TARGET_REGION)\n ec2_response = ec2_client.describe_reserved_instances(Filters=[{'Name': 'state', 'Values': ['active']}])\n if len(ec2_response['ReservedInstances']) > 0:\n print(\"Exist EC2 Reserved Instance\")\n\n ec2_ri_list = list(map(lambda a: a.values(), ec2_response['ReservedInstances']))\n ec2_head = ec2_response['ReservedInstances'][0].keys()\n ec2_df = pd.DataFrame(ec2_ri_list, columns=ec2_head)\n ec2_df['Start'] = pd.to_datetime(ec2_df['Start']).dt.tz_convert(None)\n ec2_df['End'] = pd.to_datetime(ec2_df['End']).dt.tz_convert(None)\n ec2_will_expire = ec2_df[ec2_df['End'] <= next_month]\n select_column = ['ReservedInstancesId', 'Start', 'State', 'End', 'InstanceType', 'InstanceCount']\n ec2_head2 = ec2_will_expire[select_column].columns.to_list()\n ec2_filtered_list = ec2_will_expire[select_column].values.tolist()\n\n # rds\n rds_client = boto3.client('rds', region_name=TARGET_REGION)\n rds_filtered_list, rds_head, rds_df = getExpRIList(rds_client.describe_reserved_db_instances(),\n 'ReservedDBInstances',\n 'State',\n 'active',\n ['ReservedDBInstanceId', 'StartTime', 'State', 'End', 'DBInstanceClass',\n 'DBInstanceCount'])\n\n # redshift\n red_client = boto3.client('redshift', region_name=TARGET_REGION)\n red_filtered_list, red_head, red_df = getExpRIList(red_client.describe_reserved_nodes(),\n 'ReservedNodes',\n 'State',\n 'active',\n ['ReservedNodeId', 'StartTime', 'State', 'End', 'NodeType', 'NodeCount'])\n\n # elasticache\n ec_client = boto3.client('elasticache', region_name=TARGET_REGION)\n ec_filtered_list, ec_head, ec_df = getExpRIList(ec_client.describe_reserved_cache_nodes(),\n 'ReservedCacheNodes',\n 'State',\n 'active',\n ['ReservedCacheNodeId', 'StartTime', 'State', 'End', 'CacheNodeType',\n 'CacheNodeCount'])\n\n # elasticsearch\n es_client = boto3.client('es', region_name=TARGET_REGION)\n es_filtered_list, es_head, es_df = getExpRIList(es_client.describe_reserved_elasticsearch_instances(),\n 'ReservedElasticsearchInstances',\n 'State',\n 'active',\n ['ReservationName', 'ReservedElasticsearchInstanceId', 'StartTime',\n 'State', 'End', 'ElasticsearchInstanceType',\n 'ElasticsearchInstanceCount'])\n\n to_excel(ec2_df, '/tmp/ec2_df.xlsx', lambda df: df['End'] <= next_month)\n to_excel(rds_df, '/tmp/rds_df.xlsx', lambda df: df['End'] <= next_month)\n to_excel(red_df, '/tmp/red_df.xlsx', lambda df: df['End'] <= next_month)\n to_excel(ec_df, '/tmp/ec_df.xlsx', lambda df: df['End'] <= next_month)\n to_excel(es_df, '/tmp/es_df.xlsx', lambda df: df['End'] <= next_month)\n\n html = \"<!DOCTYPE html>\\\n <html lang='en'>\\\n <head>\\\n <title>RI Status</title>\\\n <style>\\\n table, th, td {\\\n border: 1px solid black;\\\n border-collapse: collapse;\\\n font-size: 10pt;\\\n width: 1500px;\\\n }\\\n th, td {\\\n padding: 5px;\\\n text-align: left;\\\n }\\\n </style>\\\n </head>\\\n <body>\" +\\\n getHTMLTable(\"EC2\", ec2_head2, ec2_filtered_list) + \\\n getHTMLTable(\"RDS\", rds_head, rds_filtered_list) + \\\n getHTMLTable(\"Redshift\", red_head, red_filtered_list) + \\\n getHTMLTable(\"ElastiCache\", ec_head, ec_filtered_list) + \\\n getHTMLTable(\"ElasticSearch\", es_head, es_filtered_list) + \\\n \"</body></html>\"\n return html\n\n\ndef getHTMLTable(table_name, header, rows):\n html_middle = \"<h3>{}</h3><table>{}</table>\"\n table_head, table = \"\", \"\"\n table_items = []\n end_column = -1\n for index, head in enumerate(header):\n if head == \"End\":\n table_head += \"<th bgcolor='#D45B5B'>{}</th>\".format(head)\n end_column = index\n else:\n table_head += \"<th>{}</th>\".format(head)\n table_items.append(table_head)\n for row in rows:\n table_row = \"\"\n for index, item in enumerate(row):\n if index == end_column:\n table_row += \"<td bgcolor='#D45B5B'>{}</td>\".format(item)\n else:\n table_row += \"<td>{}</td>\".format(item)\n table_items.append(table_row)\n for row in table_items:\n table += \"<tr>{}</tr>\".format(row)\n table = html_middle.format(table_name, table)\n return table\n\n\ndef save_msg_to_s3(msg, bucket, obj):\n s3 = boto3.client('s3')\n s3.put_object(Body=msg, Bucket=bucket, Key=obj+\"ri_exp.html\")\n\n\ndef lambda_handler(event, context):\n # TODO implement\n dn_client = boto3.client('dynamodb', region_name=TARGET_REGION)\n dn_response = dn_client.scan(TableName='ri_exp_mailing')\n email_list = list(map(lambda a: a['email']['S'], dn_response['Items']))\n\n # if there is an email address validation in SES, send a validation email.\n ses_client = boto3.client('ses', region_name=SES_REGION)\n ses_list = list(filter(lambda a: '.com' in a, ses_client.list_identities()['Identities']))\n for i in email_list:\n if i not in ses_list:\n try:\n response = ses_client.verify_email_address(EmailAddress=i)\n except ClientError as e:\n print(e.response['Error']['Message'])\n else:\n print(\"Validation Email sent! Message ID:\"),\n print(response['MessageId'])\n\n msg = makeMessage()\n save_msg_to_s3(msg, \"ri-exp-contents\", datetime.today().strftime(\"%Y/%m/\"))\n attach = ['/tmp/ec2_df.xlsx', '/tmp/rds_df.xlsx', '/tmp/red_df.xlsx', '/tmp/ec_df.xlsx', '/tmp/es_df.xlsx']\n infos = list(map(lambda a: {'email': a, 'msg': msg, 'attach': attach}, email_list))\n\n procs = []\n for info in infos:\n p = Process(target=send_email, args=(info,))\n procs.append(p)\n p.start()\n\n for p in procs:\n p.join()\n\n return {\n 'statusCode': 200,\n 'body': json.dumps(\"success\", indent=4, sort_keys=True, default=str)\n }\n"
] |
[
[
"pandas.to_datetime",
"pandas.DataFrame",
"pandas.to_timedelta",
"pandas.ExcelWriter"
]
] |
diam045/chainer-chemistry
|
[
"aedd64049e7b2480a59c44b186171296ea69e55e",
"aedd64049e7b2480a59c44b186171296ea69e55e"
] |
[
"tests/models_tests/test_relgcn.py",
"tests/models_tests/test_relgat.py"
] |
[
"from chainer import cuda\nfrom chainer import gradient_check\nimport numpy\nimport pytest\n\nfrom chainer_chemistry.config import MAX_ATOMIC_NUM\nfrom chainer_chemistry.models.relgcn import RelGCN\nfrom chainer_chemistry.models.relgcn import rescale_adj\nfrom chainer_chemistry.utils.permutation import permute_adj\nfrom chainer_chemistry.utils.permutation import permute_node\n\natom_size = 5\nout_ch = 4\nbatch_size = 2\nnum_edge_type = 4\n\n\n@pytest.fixture\ndef model():\n return RelGCN(out_channels=out_ch)\n\n\n@pytest.fixture\ndef data():\n numpy.random.seed(0)\n atom_data = numpy.random.randint(\n 0, high=MAX_ATOMIC_NUM, size=(batch_size, atom_size)).astype('i')\n adj_data = numpy.random.randint(\n 0, high=2,\n size=(batch_size, num_edge_type, atom_size, atom_size)).astype('f')\n y_grad = numpy.random.uniform(-1, 1, (batch_size, out_ch)).astype('f')\n return atom_data, adj_data, y_grad\n\n\ndef check_forward(model, atom_data, adj_data):\n y_actual = cuda.to_cpu(model(atom_data, adj_data).data)\n assert y_actual.shape == (batch_size, out_ch)\n\n\ndef test_forward_cpu(model, data):\n atom_data, adj_data = data[0], data[1]\n check_forward(model, atom_data, adj_data)\n\n\n@pytest.mark.gpu\ndef test_forward_gpu(model, data):\n atom_data, adj_data = cuda.to_gpu(data[0]), cuda.to_gpu(data[1])\n model.to_gpu()\n check_forward(model, atom_data, adj_data)\n\n\ndef test_backward_cpu(model, data):\n atom_data, adj_data, y_grad = data\n gradient_check.check_backward(model, (atom_data, adj_data), y_grad,\n atol=1e-3, rtol=1e-3)\n\n\n@pytest.mark.gpu\ndef test_backward_gpu(model, data):\n atom_data, adj_data, y_grad = [cuda.to_gpu(d) for d in data]\n model.to_gpu()\n gradient_check.check_backward(model, (atom_data, adj_data), y_grad,\n atol=1e-3, rtol=1e-3)\n\n\ndef test_forward_cpu_invariant(model, data):\n atom_data, adj_data = data[0], data[1]\n y_actual = cuda.to_cpu(model(atom_data, adj_data).data)\n\n permutation_index = numpy.random.permutation(atom_size)\n permute_atom_data = permute_node(atom_data, permutation_index)\n permute_adj_data = permute_adj(adj_data, permutation_index)\n permute_y_actual = cuda.to_cpu(model(\n permute_atom_data, permute_adj_data).data)\n assert numpy.allclose(y_actual, permute_y_actual, rtol=1e-5, atol=1e-5)\n\n\ndef test_rescale_adj(data):\n adj = data[1]\n numpy.testing.assert_allclose(rescale_adj(adj).data.sum(axis=(1, 2)),\n numpy.ones((batch_size, atom_size)),\n atol=1e-5, rtol=1e-5)\n\n\nif __name__ == '__main__':\n pytest.main((__file__, '-v'))\n",
"from chainer import cuda\nfrom chainer import gradient_check\nimport numpy\nimport pytest\n\nfrom chainer_chemistry.config import MAX_ATOMIC_NUM\nfrom chainer_chemistry.models.relgat import RelGAT\nfrom chainer_chemistry.utils.permutation import permute_adj\nfrom chainer_chemistry.utils.permutation import permute_node\n\natom_size = 5\nout_dim = 4\nbatch_size = 2\nnum_edge_type = 4\n\n\n@pytest.fixture(params=[True, False])\ndef model(request):\n return RelGAT(out_dim=out_dim, concat_heads=request.param)\n\n\n@pytest.fixture\ndef data():\n numpy.random.seed(0)\n atom_data = numpy.random.randint(\n 0, high=MAX_ATOMIC_NUM, size=(batch_size, atom_size)\n ).astype(numpy.int32)\n adj_data = numpy.random.randint(\n 0, high=2, size=(batch_size, num_edge_type, atom_size, atom_size)\n ).astype(numpy.float32)\n y_grad = numpy.random.uniform(\n -1, 1, (batch_size, out_dim)).astype(numpy.float32)\n return atom_data, adj_data, y_grad\n\n\ndef check_forward(model, atom_data, adj_data):\n y_actual = cuda.to_cpu(model(atom_data, adj_data).data)\n assert y_actual.shape == (batch_size, out_dim)\n\n\ndef test_forward_cpu(model, data):\n atom_data, adj_data = data[0], data[1]\n check_forward(model, atom_data, adj_data)\n\n\n@pytest.mark.gpu\ndef test_forward_gpu(model, data):\n atom_data, adj_data = cuda.to_gpu(data[0]), cuda.to_gpu(data[1])\n model.to_gpu()\n check_forward(model, atom_data, adj_data)\n\n\n# TODO(mottodora): check why tolerance is high\ndef test_backward_cpu(model, data):\n atom_data, adj_data, y_grad = data\n params = tuple(model.params())\n gradient_check.check_backward(model, (atom_data, adj_data), y_grad,\n params=params, no_grads=[True, True],\n atol=1e3, rtol=1e3)\n\n\n# TODO(nakago): check why tolerance is high\n@pytest.mark.gpu\ndef test_backward_gpu(model, data):\n atom_data, adj_data, y_grad = [cuda.to_gpu(d) for d in data]\n model.to_gpu()\n params = tuple(model.params())\n gradient_check.check_backward(model, (atom_data, adj_data), y_grad,\n params=params, no_grads=[True, True],\n atol=1e3, rtol=1e3)\n\n\ndef test_forward_cpu_graph_invariant(model, data):\n atom_data, adj_data = data[0], data[1]\n y_actual = cuda.to_cpu(model(atom_data, adj_data).data)\n\n permutation_index = numpy.random.permutation(atom_size)\n permute_atom_data = permute_node(atom_data, permutation_index)\n permute_adj_data = permute_adj(adj_data, permutation_index)\n permute_y_actual = cuda.to_cpu(model(\n permute_atom_data, permute_adj_data).data)\n assert numpy.allclose(y_actual, permute_y_actual, rtol=1e-5, atol=1e-6)\n\n\nif __name__ == '__main__':\n pytest.main([__file__, '-v'])\n"
] |
[
[
"numpy.random.seed",
"numpy.random.permutation",
"numpy.ones",
"numpy.allclose",
"numpy.random.uniform",
"numpy.random.randint"
],
[
"numpy.random.seed",
"numpy.random.permutation",
"numpy.allclose",
"numpy.random.uniform",
"numpy.random.randint"
]
] |
grantseiter/Tax-Brain
|
[
"180063a193ff8cb0b56349878110066b012dde6d"
] |
[
"cs-config/cs_config/helpers.py"
] |
[
"\"\"\"\nFunctions used to help tax-brain configure to COMP\n\"\"\"\nimport os\nimport inspect\nimport time\nimport copy\nimport hashlib\nimport gzip\nimport copy\nfrom pathlib import Path\nimport warnings\n\nimport pandas as pd\nimport numpy as np\nfrom collections import defaultdict\nfrom taxbrain.report_utils import convert_params\nfrom taxcalc import (Policy, DIFF_TABLE_COLUMNS, DIFF_TABLE_LABELS,\n DIST_TABLE_COLUMNS, DIST_TABLE_LABELS,\n add_income_table_row_variable,\n add_quantile_table_row_variable, STANDARD_INCOME_BINS)\nfrom operator import itemgetter\nfrom .constants import (POLICY_SCHEMA, RESULTS_TABLE_TAGS,\n RESULTS_TABLE_TITLES, RESULTS_TOTAL_ROW_KEY_LABELS,\n MONEY_VARS)\nfrom .tables import (summary_aggregate, summary_diff_xbin, summary_diff_xdec,\n summary_dist_xbin, summary_dist_xdec)\n\ntry:\n from s3fs import S3FileSystem\nexcept ImportError as ie:\n S3FileSystem = None\n\nTCPATH = inspect.getfile(Policy)\nTCDIR = os.path.dirname(TCPATH)\n\n\nAWS_ACCESS_KEY_ID = os.environ.get(\"AWS_ACCESS_KEY_ID\", None)\nAWS_SECRET_ACCESS_KEY = os.environ.get(\"AWS_SECRET_ACCESS_KEY\", None)\n\n\ndef random_seed(user_mods, year):\n \"\"\"\n Compute random seed based on specified user_mods, which is a\n dictionary returned by Calculator.read_json_parameter_files().\n \"\"\"\n def random_seed_from_subdict(subdict):\n \"\"\"\n Compute random seed from one user_mods subdictionary.\n \"\"\"\n assert isinstance(subdict, dict)\n all_vals = []\n for year in sorted(subdict.keys()):\n all_vals.append(str(year))\n params = subdict[year]\n for param in sorted(params.keys()):\n try:\n tple = tuple(params[param])\n except TypeError:\n # params[param] is not an iterable value; make it so\n tple = tuple((params[param],))\n all_vals.append(str((param, tple)))\n txt = u''.join(all_vals).encode('utf-8')\n hsh = hashlib.sha512(txt)\n seed = int(hsh.hexdigest(), 16)\n return seed % np.iinfo(np.uint32).max\n # start of random_seed function\n # modify the user mods to work in the random_seed_from_subdict function\n # TODO: Change all of this to work with new adjustments\n user_mods_copy = copy.deepcopy(user_mods)\n beh_mods_dict = {year: {}}\n for param, value in user_mods_copy[\"behavior\"].items():\n beh_mods_dict[year][param] = [value]\n user_mods_copy[\"behavior\"] = beh_mods_dict\n ans = 0\n for subdict_name in user_mods_copy:\n subdict = user_mods_copy[subdict_name]\n if subdict_name == \"policy\":\n subdict = convert_params(subdict)\n ans += random_seed_from_subdict(subdict)\n return ans % np.iinfo(np.uint32).max\n\n\nNUM_TO_FUZZ = 3 # when using dropq algorithm on puf.csv results\n\n\ndef fuzzed(df1, df2, reform_affected, table_row_type):\n \"\"\"\n Create fuzzed df2 dataframe and corresponding unfuzzed df1 dataframe.\n\n Parameters\n ----------\n df1: Pandas DataFrame\n contains results variables for the baseline policy, which are not\n changed by this function\n\n df2: Pandas DataFrame\n contains results variables for the reform policy, which are not\n changed by this function\n\n reform_affected: boolean numpy array (not changed by this function)\n True for filing units with a reform-induced combined tax difference;\n otherwise False\n\n table_row_type: string\n valid values are 'aggr', 'xbin', and 'xdec'\n\n Returns\n -------\n df1, df2: Pandas DataFrames\n where copied df2 is fuzzed to maintain data privacy and\n where copied df1 has same filing unit order as has the fuzzed df2\n \"\"\"\n assert table_row_type in ('aggr', 'xbin', 'xdec')\n assert len(df1.index) == len(df2.index)\n assert reform_affected.size == len(df1.index)\n df1 = copy.deepcopy(df1)\n df2 = copy.deepcopy(df2)\n # add copy of reform_affected to df2\n df2['reform_affected'] = copy.deepcopy(reform_affected)\n # construct table rows, for which filing units in each row must be fuzzed\n if table_row_type == 'xbin':\n df1 = add_income_table_row_variable(df1, 'expanded_income',\n STANDARD_INCOME_BINS)\n df2['expanded_income_baseline'] = df1['expanded_income']\n df2 = add_income_table_row_variable(df2, 'expanded_income_baseline',\n STANDARD_INCOME_BINS)\n del df2['expanded_income_baseline']\n elif table_row_type == 'xdec':\n df1 = add_quantile_table_row_variable(df1, 'expanded_income',\n 10, decile_details=True)\n df2['expanded_income_baseline'] = df1['expanded_income']\n df2 = add_quantile_table_row_variable(df2, 'expanded_income_baseline',\n 10, decile_details=True)\n del df2['expanded_income_baseline']\n elif table_row_type == 'aggr':\n df1['table_row'] = np.ones(reform_affected.shape, dtype=int)\n df2['table_row'] = df1['table_row']\n gdf1 = df1.groupby('table_row', sort=False)\n gdf2 = df2.groupby('table_row', sort=False)\n del df1['table_row']\n del df2['table_row']\n # fuzz up to NUM_TO_FUZZ filing units randomly chosen in each group\n # (or table row), where fuzz means to replace the reform (2) results\n # with the baseline (1) results for each chosen filing unit\n pd.options.mode.chained_assignment = None\n group_list = list()\n for name, group2 in gdf2:\n group2 = copy.deepcopy(group2)\n indices = np.where(group2['reform_affected'])\n num = min(len(indices[0]), NUM_TO_FUZZ)\n if num > 0:\n choices = np.random.choice(indices[0], size=num, replace=False)\n group1 = gdf1.get_group(name)\n for idx in choices:\n group2.iloc[idx] = group1.iloc[idx]\n group_list.append(group2)\n del group2\n df2 = pd.concat(group_list)\n del df2['reform_affected']\n pd.options.mode.chained_assignment = 'warn'\n # reinstate index order of df1 and df2 and return\n df1.sort_index(inplace=True)\n df2.sort_index(inplace=True)\n return (df1, df2)\n\n\ndef nth_year_results(tb, year, user_mods, fuzz, return_html=True):\n \"\"\"\n Function to process taxbrain results for a given year\n \"\"\"\n start_time = time.time()\n dv1 = tb.base_data[year]\n dv2 = tb.reform_data[year]\n sres = {}\n if fuzz:\n # seed random number generator with a seed value based on user_mods\n # (reform-specific seed is used to choose whose results are fuzzed)\n seed = random_seed(user_mods, year)\n np.random.seed(seed)\n # make bool array marking which filing units are affected by the reform\n reform_affected = np.logical_not(\n np.isclose(dv1['combined'], dv2['combined'], atol=0.01, rtol=0.0)\n )\n agg1, agg2 = fuzzed(dv1, dv2, reform_affected, 'aggr')\n sres = summary_aggregate(sres, tb)\n del agg1\n del agg2\n dv1b, dv2b = fuzzed(dv1, dv2, reform_affected, 'xbin')\n sres = summary_dist_xbin(sres, tb, year)\n sres = summary_diff_xbin(sres, tb, year)\n del dv1b\n del dv2b\n dv1d, dv2d = fuzzed(dv1, dv2, reform_affected, 'xdec')\n sres = summary_dist_xdec(sres, tb, year)\n sres = summary_diff_xdec(sres, tb, year)\n del dv1d\n del dv2d\n del reform_affected\n else:\n sres = summary_aggregate(sres, tb)\n sres = summary_dist_xbin(sres, tb, year)\n sres = summary_diff_xbin(sres, tb, year)\n sres = summary_dist_xdec(sres, tb, year)\n sres = summary_diff_xdec(sres, tb, year)\n\n # optionally return non-JSON-like results\n # it would be nice to allow the user to download the full CSV instead\n # of a CSV for each year\n # what if we allowed an aggregate format call?\n # - presents project with all data proeduced in a run?\n\n if return_html:\n res = {}\n for id in sres:\n res[id] = [{\n 'dimension': year,\n 'raw': sres[id]\n }]\n elapsed_time = time.time() - start_time\n print('elapsed time for this run: {:.1f}'.format(elapsed_time))\n return res\n else:\n elapsed_time = time.time() - start_time\n print('elapsed time for this run: {:.1f}'.format(elapsed_time))\n return sres\n\n\ndef postprocess(data_to_process):\n \"\"\"\n Receives results from run_nth_year_taxcalc_model over N years,\n formats the results, and combines the aggregate results\n \"\"\"\n labels = {x: DIFF_TABLE_LABELS[i]\n for i, x in enumerate(DIFF_TABLE_COLUMNS)}\n labels.update({x: DIST_TABLE_LABELS[i]\n for i, x in enumerate(DIST_TABLE_COLUMNS)})\n\n # nested functions used below\n def label_columns(pdf):\n pdf.columns = [(labels[str(col)] if str(col) in labels else str(col))\n for col in pdf.columns]\n return pdf\n\n def append_year(pdf, year):\n \"\"\"\n append_year embedded function revises all column names in dframe\n \"\"\"\n pdf.columns = ['{}_{}'.format(col, year)\n for col in pdf.columns]\n return pdf\n\n def year_columns(pdf, year):\n pdf.columns = [str(year)]\n return pdf\n\n def arbitrary_defaultdict():\n \"\"\"\n Return an arbitrary number of defaultdicts. This is used to store all\n of the distribution and differences tables\n \"\"\"\n return defaultdict(arbitrary_defaultdict)\n\n formatted = {\"tbl_outputs\": arbitrary_defaultdict(),\n \"aggr_outputs\": defaultdict(dict)}\n downloadable = []\n year_getter = itemgetter('dimension')\n for id, pdfs in data_to_process.items():\n if id.startswith('aggr'):\n pdfs.sort(key=year_getter)\n tbl = pdfs[0][\"raw\"]\n tbl.index = pd.Index(RESULTS_TOTAL_ROW_KEY_LABELS[i]\n for i in tbl.index)\n # format table\n for col in tbl.columns:\n tbl.update(tbl[col].apply(\"${:,.2f}\".format))\n\n title = RESULTS_TABLE_TITLES[id]\n tags = RESULTS_TABLE_TAGS[id]\n formatted[\"aggr_outputs\"][tags[\"law\"]] = {\n \"title\": title,\n \"renderable\": pdf_to_clean_html(tbl)\n }\n # append a downloadable version of the results\n downloadable.append(\n {\n \"media_type\": \"CSV\",\n \"title\": title + \".csv\",\n \"data\": tbl.to_csv()\n }\n )\n\n else:\n for i in pdfs:\n year = i[\"dimension\"]\n tbl = label_columns(i[\"raw\"])\n title = '{} ({})'.format(RESULTS_TABLE_TITLES[id],\n year)\n # format table\n for col in tbl.columns:\n if col in MONEY_VARS:\n tbl.update(tbl[col].apply(\"${:,.2f}\".format))\n\n tags = RESULTS_TABLE_TAGS[id]\n tbl_type = tags[\"table_type\"]\n group = tags[\"grouping\"]\n if id.startswith(\"dist\"):\n law = tags[\"law\"]\n formatted[\"tbl_outputs\"][tbl_type][law][group][year] = {\n \"title\": title,\n \"renderable\": pdf_to_clean_html(tbl)\n }\n else:\n tax = tags[\"tax_type\"]\n formatted[\"tbl_outputs\"][tbl_type][tax][group][year] = {\n \"title\": title,\n \"renderable\": pdf_to_clean_html(tbl)\n }\n\n # add downloadable information\n downloadable.append(\n {\n \"media_type\": \"CSV\",\n \"title\": title + \".csv\",\n \"data\": tbl.to_csv()\n }\n )\n\n return formatted, downloadable\n\n\ndef pdf_to_clean_html(pdf):\n \"\"\"Takes a PDF and returns an HTML table without any deprecated tags or\n irrelevant styling\"\"\"\n tb_replace = ('<table class=\"table table-striped\"')\n\n return (pdf.to_html()\n .replace('<table ', tb_replace)\n .replace(' border=\"1\"', '')\n .replace('class=\"dataframe\"', ''))\n\n\ndef retrieve_puf(\n aws_access_key_id=AWS_ACCESS_KEY_ID, aws_secret_access_key=AWS_SECRET_ACCESS_KEY\n):\n \"\"\"\n Function for retrieving the PUF from the OSPC S3 bucket\n \"\"\"\n s3_reader_installed = S3FileSystem is not None\n has_credentials = (\n aws_access_key_id is not None and aws_secret_access_key is not None\n )\n if has_credentials and s3_reader_installed:\n print(\"Reading puf from S3 bucket.\")\n fs = S3FileSystem(key=AWS_ACCESS_KEY_ID, secret=AWS_SECRET_ACCESS_KEY,)\n with fs.open(\"s3://ospc-data-files/puf.csv.gz\") as f:\n # Skips over header from top of file.\n puf_df = pd.read_csv(f, compression=\"gzip\")\n return puf_df\n elif Path(\"puf.csv.gz\").exists():\n print(\"Reading puf from puf.csv.gz.\")\n return pd.read_csv(\"puf.csv.gz\", compression=\"gzip\")\n elif Path(\"puf.csv\").exists():\n print(\"Reading puf from puf.csv.\")\n return pd.read_csv(\"puf.csv\")\n else:\n warnings.warn(\n f\"PUF file not available (has_credentials={has_credentials}, \"\n f\"s3_reader_installed={s3_reader_installed})\"\n )\n return None\n"
] |
[
[
"pandas.Index",
"numpy.isclose",
"numpy.random.choice",
"numpy.random.seed",
"numpy.ones",
"numpy.where",
"pandas.concat",
"pandas.read_csv",
"numpy.iinfo"
]
] |
nickgerend/Downtown
|
[
"165d3143ac69fd661050b73c3580e1221da981f8"
] |
[
"linework.py"
] |
[
"# Written by: Nick Gerend, @dataoutsider\n# Viz: \"Downtown\", enjoy!\n\nimport matplotlib.pyplot as plt\n\n#region Functions\n\ndef line_slope_intercept(x1, y1, x2, y2):\n m = (y2 - y1) / (x2 - x1)\n b = y1 - m * x1\n return m, b # y = mx + b\n\ndef two_lines_intercept(m1, b1, m2, b2):\n x = (b2 - b1) / (m1 - m2)\n y = m1 * x + b1\n return x, y\n\ndef two_lines_intercept2(p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y):\n s1_x = p1_x - p0_x \n s1_y = p1_y - p0_y\n s2_x = p3_x - p2_x\n s2_y = p3_y - p2_y\n #s = (-s1_y * (p0_x - p2_x) + s1_x * (p0_y - p2_y)) / (-s2_x * s1_y + s1_x * s2_y)\n t = ( s2_x * (p0_y - p2_y) - s2_y * (p0_x - p2_x)) / (-s2_x * s1_y + s1_x * s2_y)\n i_x = p0_x + (t * s1_x)\n i_y = p0_y + (t * s1_y)\n return i_x, i_y\n\n#endregion\n\n#region Classes\n\nclass building:\n def __init__(self, row, column, path, x, y): \n self.row = row\n self.column = column\n self.path = path\n self.x = x\n self.y = y\n\nclass lines:\n def __init__(self, line, x1, y1, x2, y2): \n self.line = line\n self.x1 = x1\n self.y1 = y1\n self.x2 = x2\n self.y2 = y2\n\nclass intercept:\n def __init__(self, intercept, line1, line2): \n self.intercept = intercept\n self.x1 = line1.x1\n self.y1 = line1.y1\n self.x2 = line1.x2\n self.y2 = line1.y2\n self.x3 = line2.x1\n self.y3 = line2.y1\n self.x4 = line2.x2\n self.y4 = line2.y2\n self.iPoint_x = 0.0\n self.iPoint_y = 0.0\n def calc_iPoint(self):\n self.iPoint_x, self.iPoint_y = two_lines_intercept2(self.x1, self.y1, self.x2, self.y2, self.x3, self.y3, self.x4, self.y4)\n\n#endregion\n\n#region Initialize\nwidth_height_ratio = 0.8\nhalf_whr = width_height_ratio / 2\n\nV_x = 10.0\nV_y = 5.0\n\nlines_list = []\n\n# A1:\nlines_list.append(lines('a1', half_whr, 0.0, half_whr, 1.0))\nlines_list.append(lines('a1_', 0.0, 0.0, V_x, V_y))\nA1_i = intercept('A1', lines_list[0], lines_list[1])\nA1_i.calc_iPoint()\nA1_x = A1_i.iPoint_x\nA1_y = A1_i.iPoint_y\n\n# A2:\nlines_list.append(lines('a2', half_whr, 0.0, half_whr, 1.0))\nlines_list.append(lines('a2_', 0.0, 0.5, V_x, V_y))\nA2_i = intercept('A2', lines_list[2], lines_list[3])\nA2_i.calc_iPoint()\nA2_x = A2_i.iPoint_x\nA2_y = A2_i.iPoint_y\n\n# A3:\nlines_list.append(lines('a3', half_whr, 0.0, half_whr, 1.0))\nlines_list.append(lines('a3_', 0.0, 1.0, V_x, V_y))\nA3_i = intercept('A3', lines_list[4], lines_list[5])\nA3_i.calc_iPoint()\nA3_x = A3_i.iPoint_x\nA3_y = A3_i.iPoint_y\n\nbuilding_list = []\nbuilding_list.append(building(0.0, 0.0, -1.0, 0.0, 0.0)) \nbuilding_list.append(building(0.5, 0.0, -1.0, 0.0, 0.5))\nbuilding_list.append(building(1.0, 0.0, -1.0, 0.0, 1.0))\nbuilding_list.append(building(0.0, 0.5, -1.0, A1_x, A1_y))\nbuilding_list.append(building(0.5, 0.5, -1.0, A2_x, A2_y))\nbuilding_list.append(building(1.0, 0.5, -1.0, A3_x, A3_y))\n\n#endregion\n\n#region Loop\n\ncolumns = 8\ncol_counter = 1\ndiag_point = 2\n\nfor j in range(2 * columns - 1):\n \n lines_list.clear()\n\n #region Calc Points\n # A1:\n lines_list.append(lines('a1', building_list[diag_point].x, building_list[diag_point].y, building_list[diag_point + 2].x, building_list[diag_point + 2].y))\n lines_list.append(lines('a1_', 0.0, 0.0, V_x, V_y))\n A1_i = intercept('A1', lines_list[0], lines_list[1])\n A1_i.calc_iPoint()\n A1_x = A1_i.iPoint_x\n A1_y = A1_i.iPoint_y\n\n # A2:\n lines_list.append(lines('a2', A1_x, 0.0, A1_x, 1.0))\n lines_list.append(lines('a2_', 0.0, 0.5, V_x, V_y))\n A2_i = intercept('A2', lines_list[2], lines_list[3])\n A2_i.calc_iPoint()\n A2_x = A2_i.iPoint_x\n A2_y = A2_i.iPoint_y\n\n # A3:\n lines_list.append(lines('a3', A1_x, 0.0, A1_x, 1.0))\n lines_list.append(lines('a3_', 0.0, 1.0, V_x, V_y))\n A3_i = intercept('A3', lines_list[4], lines_list[5])\n A3_i.calc_iPoint()\n A3_x = A3_i.iPoint_x\n A3_y = A3_i.iPoint_y\n #endregion\n\n building_list.append(building(0.0, col_counter, -1.0, A1_x, A1_y))\n building_list.append(building(0.5, col_counter, -1.0, A2_x, A2_y))\n building_list.append(building(1.0, col_counter, -1.0, A3_x, A3_y))\n\n col_counter += .5\n diag_point += 3\n\n# Diagram:\n#\n# 1.0 --b----A3----B3--------- \\\n# 0.5 --|---A2,b---B2--------- > (x_offset, y_offset) vanishing point\n# ^ 0.0 --|----A1----B1--------- /\n# y a,c\n# x > 0.0 [*/2] [w/h]*\n\n#endregion\n\n#region Display points\n\nx = [o.x for o in building_list if (o.column % 1 == 0) and (o.row % 1 == 0)]\ny = [o.y for o in building_list if (o.column % 1 == 0) and (o.row % 1 == 0)]\nplt.scatter(x, y)\nplt.show()\n\n#endregion\n\n#region Create polygons\nFFR = [o for o in building_list if (o.column % 1 == 0) and (o.row % 1 == 0)] # First Floor Right\nbuilding_poly = []\nindex = 0\nfor i in range(columns):\n index = 2 * i\n building_poly.append(building(0, index, 0, FFR[index].x, FFR[index].y))\n building_poly.append(building(0, index, 1, FFR[index+2].x, FFR[index+2].y))\n building_poly.append(building(0, index, 2, FFR[index+3].x, FFR[index+3].y))\n building_poly.append(building(0, index, 3, FFR[index+1].x, FFR[index+1].y))\n#endregion\n\n#region Write out file\nimport csv\nimport os\nwith open(os.path.dirname(__file__) + '/building.csv', 'w',) as csvfile:\n writer = csv.writer(csvfile, lineterminator = '\\n')\n writer.writerow(['row', 'column', 'path', 'x', 'y'])\n for window in building_poly:\n writer.writerow([window.row, window.column, window.path, window.x, window.y])\n#endregion"
] |
[
[
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.show"
]
] |
grburgess/gammapy
|
[
"609e460698caca7223afeef5e71826c7b32728d1",
"609e460698caca7223afeef5e71826c7b32728d1",
"609e460698caca7223afeef5e71826c7b32728d1",
"609e460698caca7223afeef5e71826c7b32728d1",
"609e460698caca7223afeef5e71826c7b32728d1"
] |
[
"gammapy/scripts/tests/test_image_fit.py",
"gammapy/detect/tests/test_lima.py",
"gammapy/image/tests/test_catalog.py",
"gammapy/utils/coordinates/celestial.py",
"gammapy/utils/tests/test_energy.py"
] |
[
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\nfrom __future__ import absolute_import, division, print_function, unicode_literals\nimport json\nfrom numpy.testing.utils import assert_allclose\nfrom astropy.stats import gaussian_sigma_to_fwhm\nfrom astropy.tests.helper import pytest\nfrom ...utils.testing import requires_dependency, requires_data, run_cli\nfrom ...datasets import load_poisson_stats_image\nfrom ..image_fit import image_fit\n\n\nEXPECTED = ([9.016526, 99.865985, 100.147877, 1010.824189],\n [4 * gaussian_sigma_to_fwhm, 100, 100, 1E3],\n [5 * gaussian_sigma_to_fwhm, 100, 100, 1E3])\nRTOL = (1E-5, 1E-3, 1E-3)\nPSF = (True, True, False)\nDATA = (True, False, False)\n\n@requires_dependency('sherpa')\n@requires_data('gammapy-extra')\n@pytest.mark.parametrize('expected, rtol, psf, data',\n zip(EXPECTED, RTOL, PSF, DATA))\ndef test_sherpa_like(tmpdir, expected, rtol, psf, data):\n \"\"\"\n Fit Poisson stats image test data.\n \"\"\"\n\n # load test data\n filenames = load_poisson_stats_image(extra_info=True, return_filenames=True)\n outfile = tmpdir / 'test_sherpa_like.json'\n\n # write test source json file\n sources_data = {}\n sources_data['gaussian'] = {'ampl': 1E3,\n 'xpos': 99,\n 'ypos': 99,\n 'fwhm': 4 * gaussian_sigma_to_fwhm}\n\n filename = tmpdir / 'test_sherpa_like_sources.json'\n with filename.open('w') as fh:\n json.dump(sources_data, fh)\n\n # set up args\n args = {'exposure': str(filenames['exposure']),\n 'background': str(filenames['background']),\n 'sources': str(filename),\n 'roi': None,\n 'outfile': str(outfile)}\n\n if data:\n args['counts'] = str(filenames['counts'])\n else:\n args['counts'] = str(filenames['model'])\n if psf:\n args['psf'] = filenames['psf']\n else:\n args['psf'] = None\n\n image_fit(**args)\n\n with outfile.open() as fh:\n data = json.load(fh)\n\n # This recovers the values from the test dataset documented here:\n # https://github.com/gammapy/gammapy-extra/tree/master/\n # test_datasets/unbundled/poisson_stats_image#data\n actual = data['fit']['parvals']\n assert_allclose(actual, expected, rtol=rtol)\n\n",
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\nfrom __future__ import absolute_import, division, print_function, unicode_literals\n\nimport numpy as np\nfrom numpy.testing.utils import assert_allclose, assert_equal\n\nfrom astropy.convolution import Tophat2DKernel\nfrom astropy.io import fits\n\nfrom ...utils.testing import requires_dependency, requires_data\nfrom ...detect import compute_ts_map, compute_lima_map, compute_lima_on_off_map\nfrom ...datasets import load_poisson_stats_image, gammapy_extra\nfrom ...image import SkyImageCollection, SkyImage\n\nfrom ...extern.pathlib import Path\n\n\n@requires_dependency('scipy')\n@requires_data('gammapy-extra')\ndef test_compute_lima_map():\n \"\"\"\n Test Li&Ma map against TS map for Tophat kernel\n \"\"\"\n filenames = load_poisson_stats_image(extra_info=True, return_filenames=True)\n data = SkyImageCollection()\n data.counts = SkyImage.read(filenames['counts'])\n data.background = SkyImage.read(filenames['background'])\n data.exposure = SkyImage.read(filenames['exposure'])\n\n kernel = Tophat2DKernel(5)\n result_lima = compute_lima_map(data['counts'], data['background'], kernel,\n data['exposure'])\n kernel.normalize('integral')\n result_ts = compute_ts_map(data['counts'], data['background'], data['exposure'],\n kernel)\n\n assert_allclose(result_ts.sqrt_ts, result_lima.significance, atol=1E-3)\n assert_allclose(result_ts.amplitude, result_lima.flux, atol=3E-12)\n\n\n@requires_dependency('scipy')\n@requires_data('gammapy-extra')\ndef test_compute_lima_on_off_map():\n \"\"\"\n Test Li&Ma map with snippet from the H.E.S.S. survey data.\n \"\"\"\n filename = gammapy_extra.filename('test_datasets/unbundled/hess/survey/'\n 'hess_survey_snippet.fits.gz')\n maps = SkyImageCollection.read(filename)\n\n kernel = Tophat2DKernel(5)\n\n result_lima = compute_lima_on_off_map(maps.on.data, maps.off.data, maps.onexposure.data,\n maps.offexposure.data, kernel)\n\n # reproduce safe significance threshold from HESS software\n result_lima.significance.data[result_lima.n_on.data < 5] = 0\n\n # Set boundary to NaN in reference image\n maps.significance.data[np.isnan(result_lima.significance)] = np.nan\n assert_allclose(result_lima.significance, maps.significance, atol=1E-5)\n",
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\nfrom __future__ import absolute_import, division, print_function, unicode_literals\nfrom numpy.testing import assert_allclose\nfrom astropy.units import Quantity\nfrom astropy.wcs import WCS\nfrom ...utils.testing import requires_dependency, requires_data\nfrom .. import catalog\nfrom ...image import SkyImage\nfrom ...irf import EnergyDependentTablePSF\nfrom ...cube import SkyCube\nfrom ...datasets import FermiGalacticCenter\n\n\ndef test_extended_image():\n # TODO: implement me\n pass\n\n\n@requires_data('gammapy-extra')\ndef test_source_image():\n reference_hdu = SkyImage.empty(nxpix=10, nypix=10, binsz=1).to_image_hdu()\n reference_wcs = WCS(reference_hdu.header)\n energy = Quantity([10, 500], 'GeV')\n reference = SkyCube(data=reference_hdu.data,\n wcs=reference_wcs, energy=energy)\n\n psf_file = FermiGalacticCenter.filenames()['psf']\n psf = EnergyDependentTablePSF.read(psf_file)\n\n image, energies = catalog._source_image(catalog='1FHL',\n reference_cube=reference,\n total_flux=True)\n\n actual = image.sum()\n # Flux of sources within a 10x10 deg region about Galactic Center\n expected = 1.6098631760996795e-07\n assert_allclose(actual, expected)\n\n\n@requires_dependency('scipy')\n@requires_data('gammapy-extra')\ndef test_catalog_image():\n reference_hdu = SkyImage.empty(nxpix=10, nypix=10, binsz=1).to_image_hdu()\n reference_wcs = WCS(reference_hdu.header)\n energy = Quantity([10, 500], 'GeV')\n\n psf_file = FermiGalacticCenter.filenames()['psf']\n psf = EnergyDependentTablePSF.read(psf_file)\n\n out_cube = catalog.catalog_image(reference_hdu, psf, catalog='1FHL',\n source_type='point', total_flux=True,\n sim_table=None)\n\n actual = out_cube.data.sum()\n\n # Ensures flux is consistent following PSF convolution to within 1%\n expected = 1.6098631760996795e-07\n assert_allclose(actual, expected, rtol=0.01)\n\n\n@requires_data('gammapy-extra')\ndef test_catalog_table():\n # Checks catalogs are loaded correctly\n\n table_1fhl = catalog.catalog_table('1FHL')\n assert len(table_1fhl) == 514\n\n table_2fgl = catalog.catalog_table('2FGL')\n assert len(table_2fgl) == 1873\n",
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\n\"\"\"Celestial coordinate utility functions.\n\"\"\"\nfrom __future__ import absolute_import, division, print_function, unicode_literals\nimport numpy as np\nfrom numpy import (cos, sin, arccos, arcsin,\n arctan2, radians, degrees, pi)\n\n__all__ = ['galactic_to_radec',\n 'radec_to_galactic',\n 'separation',\n 'minimum_separation',\n 'pair_correlation',\n ]\n\n\ndef galactic_to_radec(glon, glat, unit='deg'):\n \"\"\"Convert Galactic to Equatorial J2000 coordinates.\n\n Parameters\n ----------\n glon, glat : array_like\n Galactic coordinates\n unit : {'deg', 'rad'}\n Units of input and output coordinates\n\n Returns\n -------\n ra, dec : array_like\n Equatorial coordinates.\n\n Notes\n -----\n This is a standalone implementation that only uses ``numpy`` for testing.\n Use `~astropy.coordinates.SkyCoord` instead.\n Only accurate to ~ 3 digits.\n \"\"\"\n if unit == 'deg':\n glon, glat = radians(glon), radians(glat)\n\n ra_gp = radians(192.85948)\n de_gp = radians(27.12825)\n lcp = radians(122.932)\n\n term1 = cos(glat) * sin(lcp - glon)\n term2 = cos(de_gp) * sin(glat) - sin(de_gp) * cos(glat) * cos(lcp - glon)\n ramragp = arctan2(term1, term2)\n ra = (ramragp + ra_gp + 2 * pi) % (2 * pi)\n\n sin_d = sin(de_gp) * sin(glat) + cos(de_gp) * cos(glat) * cos(lcp - glon)\n dec = arcsin(sin_d)\n\n if unit == 'deg':\n ra, dec = degrees(ra), degrees(dec)\n\n return ra, dec\n\n\ndef radec_to_galactic(ra, dec, unit='deg'):\n \"\"\"Convert Equatorial J2000 to Galactic coordinates.\n\n Parameters\n ----------\n ra, dec : array_like\n Equatorial coordinates.\n unit : {'deg', 'rad'}\n Units of input and output coordinates\n\n Returns\n -------\n glon, glat : array_like\n Galactic coordinates\n\n Notes\n -----\n This is a standalone implementation that only uses ``numpy`` for testing.\n Use `~astropy.coordinates.SkyCoord` instead.\n Only accurate to ~ 3 digits.\n \"\"\"\n if unit == 'deg':\n ra, dec = radians(ra), radians(dec)\n\n ra_gp = radians(192.85948)\n de_gp = radians(27.12825)\n lcp = radians(122.932)\n\n term1 = cos(dec) * sin(ra - ra_gp)\n term2 = cos(de_gp) * sin(dec) - sin(de_gp) * cos(dec) * cos(ra - ra_gp)\n lcpml = arctan2(term1, term2)\n glon = (lcp - lcpml + 2 * pi) % (2 * pi)\n\n sin_b = sin(de_gp) * sin(dec) + cos(de_gp) * cos(dec) * cos(ra - ra_gp)\n glat = arcsin(sin_b)\n\n if unit == 'deg':\n glon, glat = degrees(glon), degrees(glat)\n\n return glon, glat\n\n\ndef separation(lon1, lat1, lon2, lat2, unit='deg'):\n \"\"\"Angular separation between points on the sphere.\n\n Parameters\n ----------\n lon1, lat1, lon2, lat2 : array_like\n Coordinates of the two points\n unit : {'deg', 'rad'}\n Units of input and output coordinates\n\n Returns\n -------\n separation : array_like\n Angular separation\n \"\"\"\n if unit == 'deg':\n lon1, lat1, lon2, lat2 = map(radians, (lon1, lat1, lon2, lat2))\n\n term1 = cos(lat1) * cos(lon1) * cos(lat2) * cos(lon2)\n term2 = cos(lat1) * sin(lon1) * cos(lat2) * sin(lon2)\n term3 = sin(lat1) * sin(lat2)\n mu = term1 + term2 + term3\n separation = arccos(mu)\n\n if unit == 'deg':\n separation = degrees(separation)\n\n return separation\n\n\ndef minimum_separation(lon1, lat1, lon2, lat2, unit='deg'):\n \"\"\"Compute minimum distance of each (lon1, lat1) to any (lon2, lat2).\n\n Parameters\n ----------\n lon1, lat1 : array_like\n Primary coordinates of interest\n lon2, lat2 : array_like\n Counterpart coordinate array\n unit : {'deg', 'rad'}\n Units of input and output coordinates\n\n Returns\n -------\n theta_min : array\n Minimum distance\n \"\"\"\n lon1 = np.asanyarray(lon1)\n lat1 = np.asanyarray(lat1)\n\n theta_min = np.empty_like(lon1, dtype=np.float64)\n\n for i1 in range(lon1.size):\n thetas = separation(lon1[i1], lat1[i1],\n lon2, lat2, unit=unit)\n theta_min[i1] = thetas.min()\n\n return theta_min\n\n\ndef pair_correlation(lon, lat, theta_bins, unit='deg'):\n \"\"\"Compute pair correlation function for points on the sphere.\n\n Parameters\n ----------\n lon, lat : array_like\n Coordinate arrays\n theta_bins : array_like\n Array defining the ``theta`` binning.\n ``theta`` is the angular offset between positions.\n unit : {'deg', 'rad'}\n Units of input and output coordinates\n\n Returns\n -------\n counts : array\n Array of point separations per ``theta`` bin.\n \"\"\"\n # TODO: Implement speedups:\n # - use radians\n # - avoid processing each pair twice (distance a to b and b to a)\n counts = np.zeros(shape=len(theta_bins) - 1, dtype=int)\n # If there are many points this should have acceptable performance\n # because the inner loop is in np.histogram, not in Python\n for ii in range(len(lon)):\n theta = separation(lon[ii], lat[ii], lon, lat, unit=unit)\n hist = np.histogram(theta, theta_bins)[0]\n counts += hist\n\n return counts\n",
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\nfrom __future__ import absolute_import, division, print_function, unicode_literals\nimport numpy as np\nfrom numpy.testing import assert_equal, assert_allclose\nimport astropy.units as u\nfrom astropy.io import fits\nfrom ...utils.testing import requires_data\nfrom ...datasets import gammapy_extra\nfrom ...utils.energy import Energy, EnergyBounds\n\n\ndef test_Energy():\n # Explicit constructor call\n energy = Energy([1, 3, 6, 8, 12], 'TeV')\n actual = str(energy.__class__)\n desired = \"<class 'gammapy.utils.energy.Energy'>\"\n assert_equal(actual, desired)\n\n val = u.Quantity([1, 3, 6, 8, 12], 'TeV')\n actual = Energy(val, 'GeV')\n desired = Energy((1, 3, 6, 8, 12), 'TeV')\n assert_equal(actual, desired)\n\n # View casting\n energy = val.view(Energy)\n actual = type(energy).__module__\n desired = 'gammapy.utils.energy'\n assert_equal(actual, desired)\n\n # New from template\n energy = Energy([0, 1, 2, 3, 4, 5], 'eV')\n energy2 = energy[1:3]\n actual = energy2\n desired = Energy([1, 2], 'eV')\n assert_equal(actual, desired)\n\n actual = energy2.nbins\n desired = 2\n assert_equal(actual, desired)\n\n actual = energy2.unit\n desired = u.eV\n assert_equal(actual, desired)\n\n # Equal log spacing\n energy = Energy.equal_log_spacing(1 * u.GeV, 10 * u.TeV, 6)\n actual = energy[0]\n desired = Energy(1 * u.GeV, 'TeV')\n assert_equal(actual, desired)\n\n energy = Energy.equal_log_spacing(2, 6, 3, 'GeV')\n actual = energy.nbins\n desired = 3\n assert_equal(actual, desired)\n\n # range + nbins\n erange = energy.range.value\n bins = energy.nbins\n actual = np.logspace(np.log10(erange[0]), np.log10(erange[1]), bins)\n desired = energy.value\n assert_equal(actual, desired)\n\n # Input string\n e_string = '10 TeV'\n actual = Energy(e_string)\n desired = Energy(10, 'TeV')\n assert_equal(actual, desired)\n\n e_string = u'10 TeV'\n actual = Energy(e_string)\n desired = Energy(10, 'TeV')\n assert_equal(actual, desired)\n\n\ndef test_EnergyBounds():\n val = u.Quantity([1, 2, 3, 4, 5], 'TeV')\n actual = EnergyBounds(val, 'GeV')\n desired = EnergyBounds((1, 2, 3, 4, 5), 'TeV')\n assert_equal(actual, desired)\n\n # View casting\n energy = val.view(EnergyBounds)\n actual = type(energy).__module__\n desired = 'gammapy.utils.energy'\n assert_equal(actual, desired)\n\n # New from template\n energy = EnergyBounds([0, 1, 2, 3, 4, 5], 'keV')\n energy2 = energy[1:4]\n actual = energy2\n desired = EnergyBounds([1, 2, 3], 'keV')\n assert_equal(actual, desired)\n\n actual = energy2.nbins\n desired = 2\n assert_equal(actual, desired)\n\n actual = energy2.unit\n desired = u.keV\n assert_equal(actual, desired)\n\n # Equal log spacing\n energy = EnergyBounds.equal_log_spacing(1 * u.TeV, 10 * u.TeV, 10)\n actual = energy.nbins\n desired = 10\n assert_equal(actual, desired)\n\n # Log centers\n center = energy.log_centers\n actual = type(center).__module__\n desired = 'gammapy.utils.energy'\n assert_equal(actual, desired)\n\n # Upper/lower bounds\n actual = energy.upper_bounds\n desired = energy[1:]\n assert_equal(actual, desired)\n\n actual = energy.lower_bounds\n desired = energy[:-1]\n assert_equal(actual, desired)\n\n lower = [1, 3, 4, 5]\n upper = [3, 4, 5, 8]\n actual = EnergyBounds.from_lower_and_upper_bounds(lower, upper, 'TeV')\n desired = EnergyBounds([1, 3, 4, 5, 8], 'TeV')\n assert_equal(actual, desired)\n\n # Range\n erange = energy.range\n actual = erange[0]\n desired = energy[0]\n assert_equal(actual, desired)\n actual = erange[1]\n desired = energy[-1]\n assert_equal(actual, desired)\n\n # Bands\n bands = energy.bands\n actual = bands[0]\n desired = energy[1] - energy[0]\n assert_equal(actual, desired)\n\n\n@requires_data('gammapy-extra')\ndef test_EnergyBounds_read():\n # read EBOUNDS extension\n filename = gammapy_extra.filename('test_datasets/irf/hess/ogip/run_rmf60741.fits')\n\n hdulist = fits.open(filename)\n ebounds = EnergyBounds.from_ebounds(hdulist['EBOUNDS'])\n desired = hdulist['EBOUNDS'].data['E_MAX'][-1]\n actual = ebounds[-1].value\n assert_equal(actual, desired)\n\n # read MATRIX extension\n ebounds = EnergyBounds.from_rmf_matrix(hdulist['MATRIX'])\n desired = hdulist['MATRIX'].data['ENERG_LO'][3]\n actual = ebounds[3].value\n assert_equal(actual, desired)\n\n\ndef test_EnergyBounds_write(tmpdir):\n ebounds = EnergyBounds.equal_log_spacing(1 * u.TeV, 10 * u.TeV, 10)\n writename = str(tmpdir / 'ebounds_test.fits')\n hdu = ebounds.to_ebounds()\n prim_hdu = fits.PrimaryHDU()\n hdulist = fits.HDUList([prim_hdu, hdu])\n hdulist.writeto(writename)\n\n ebounds2 = EnergyBounds.from_ebounds(hdulist[1])\n actual = ebounds2\n desired = ebounds\n assert_allclose(actual, desired)\n"
] |
[
[
"numpy.testing.utils.assert_allclose"
],
[
"numpy.isnan",
"numpy.testing.utils.assert_allclose"
],
[
"numpy.testing.assert_allclose"
],
[
"numpy.histogram",
"numpy.sin",
"numpy.arccos",
"numpy.arcsin",
"numpy.degrees",
"numpy.radians",
"numpy.arctan2",
"numpy.cos",
"numpy.asanyarray",
"numpy.empty_like"
],
[
"numpy.testing.assert_allclose",
"numpy.log10",
"numpy.testing.assert_equal"
]
] |
owennewo/kfserving
|
[
"89f73c87525b8e06ea799f69f2979c4ad272fcb3",
"89f73c87525b8e06ea799f69f2979c4ad272fcb3",
"6aa83398ab03bfae822f36772757097bcb98b6ed",
"6aa83398ab03bfae822f36772757097bcb98b6ed",
"89f73c87525b8e06ea799f69f2979c4ad272fcb3",
"89f73c87525b8e06ea799f69f2979c4ad272fcb3",
"89f73c87525b8e06ea799f69f2979c4ad272fcb3"
] |
[
"vendor/github.com/tensorflow/tensorflow/tensorflow/python/ops/linalg/linear_operator_kronecker.py",
"docs/samples/explanation/alibi/alibi_helper.py",
"vendor/github.com/tensorflow/tensorflow/tensorflow/contrib/distribute/python/examples/simple_estimator_example.py",
"vendor/github.com/tensorflow/tensorflow/tensorflow/python/ops/sparse_ops_test.py",
"vendor/github.com/tensorflow/tensorflow/tensorflow/python/data/experimental/benchmarks/csv_dataset_benchmark.py",
"vendor/github.com/tensorflow/tensorflow/tensorflow/python/autograph/converters/control_flow_test.py",
"vendor/github.com/tensorflow/tensorflow/tensorflow/python/data/kernel_tests/take_test.py"
] |
[
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Construct the Kronecker product of one or more `LinearOperators`.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import errors\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import check_ops\nfrom tensorflow.python.ops import control_flow_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops.linalg import linalg_impl as linalg\nfrom tensorflow.python.ops.linalg import linear_operator\nfrom tensorflow.python.util.tf_export import tf_export\n\n__all__ = [\"LinearOperatorKronecker\"]\n\n\ndef _vec(x):\n \"\"\"Stacks column of matrix to form a single column.\"\"\"\n return array_ops.reshape(\n array_ops.matrix_transpose(x),\n array_ops.concat(\n [array_ops.shape(x)[:-2], [-1]], axis=0))\n\n\ndef _unvec_by(y, num_col):\n \"\"\"Unstack vector to form a matrix, with a specified amount of columns.\"\"\"\n return array_ops.matrix_transpose(\n array_ops.reshape(\n y,\n array_ops.concat(\n [array_ops.shape(y)[:-1], [num_col, -1]], axis=0)))\n\n\ndef _rotate_last_dim(x, rotate_right=False):\n \"\"\"Rotate the last dimension either left or right.\"\"\"\n ndims = array_ops.rank(x)\n if rotate_right:\n transpose_perm = array_ops.concat(\n [[ndims - 1], math_ops.range(0, ndims - 1)], axis=0)\n else:\n transpose_perm = array_ops.concat(\n [math_ops.range(1, ndims), [0]], axis=0)\n return array_ops.transpose(x, transpose_perm)\n\n\n@tf_export(\"linalg.LinearOperatorKronecker\")\nclass LinearOperatorKronecker(linear_operator.LinearOperator):\n \"\"\"Kronecker product between two `LinearOperators`.\n\n This operator composes one or more linear operators `[op1,...,opJ]`,\n building a new `LinearOperator` representing the Kronecker product:\n `op1 x op2 x .. opJ` (we omit parentheses as the Kronecker product is\n associative).\n\n If `opj` has shape `batch_shape_j` + [M_j, N_j`, then the composed operator\n will have shape equal to `broadcast_batch_shape + [prod M_j, prod N_j]`,\n where the product is over all operators.\n\n ```python\n # Create a 4 x 4 linear operator composed of two 2 x 2 operators.\n operator_1 = LinearOperatorFullMatrix([[1., 2.], [3., 4.]])\n operator_2 = LinearOperatorFullMatrix([[1., 0.], [2., 1.]])\n operator = LinearOperatorKronecker([operator_1, operator_2])\n\n operator.to_dense()\n ==> [[1., 2., 0., 0.],\n [3., 4., 0., 0.],\n [2., 4., 1., 2.],\n [6., 8., 3., 4.]]\n\n operator.shape\n ==> [4, 4]\n\n operator.log_abs_determinant()\n ==> scalar Tensor\n\n x = ... Shape [4, 2] Tensor\n operator.matmul(x)\n ==> Shape [4, 2] Tensor\n\n # Create a [2, 3] batch of 4 x 5 linear operators.\n matrix_45 = tf.random_normal(shape=[2, 3, 4, 5])\n operator_45 = LinearOperatorFullMatrix(matrix)\n\n # Create a [2, 3] batch of 5 x 6 linear operators.\n matrix_56 = tf.random_normal(shape=[2, 3, 5, 6])\n operator_56 = LinearOperatorFullMatrix(matrix_56)\n\n # Compose to create a [2, 3] batch of 20 x 30 operators.\n operator_large = LinearOperatorKronecker([operator_45, operator_56])\n\n # Create a shape [2, 3, 20, 2] vector.\n x = tf.random_normal(shape=[2, 3, 6, 2])\n operator_large.matmul(x)\n ==> Shape [2, 3, 30, 2] Tensor\n ```\n\n #### Performance\n\n The performance of `LinearOperatorKronecker` on any operation is equal to\n the sum of the individual operators' operations.\n\n #### Matrix property hints\n\n This `LinearOperator` is initialized with boolean flags of the form `is_X`,\n for `X = non_singular, self_adjoint, positive_definite, square`.\n These have the following meaning:\n\n * If `is_X == True`, callers should expect the operator to have the\n property `X`. This is a promise that should be fulfilled, but is *not* a\n runtime assert. For example, finite floating point precision may result\n in these promises being violated.\n * If `is_X == False`, callers should expect the operator to not have `X`.\n * If `is_X == None` (the default), callers should have no expectation either\n way.\n \"\"\"\n\n def __init__(self,\n operators,\n is_non_singular=None,\n is_self_adjoint=None,\n is_positive_definite=None,\n is_square=None,\n name=None):\n r\"\"\"Initialize a `LinearOperatorKronecker`.\n\n `LinearOperatorKronecker` is initialized with a list of operators\n `[op_1,...,op_J]`.\n\n Args:\n operators: Iterable of `LinearOperator` objects, each with\n the same `dtype` and composable shape, representing the Kronecker\n factors.\n is_non_singular: Expect that this operator is non-singular.\n is_self_adjoint: Expect that this operator is equal to its hermitian\n transpose.\n is_positive_definite: Expect that this operator is positive definite,\n meaning the quadratic form `x^H A x` has positive real part for all\n nonzero `x`. Note that we do not require the operator to be\n self-adjoint to be positive-definite. See:\n https://en.wikipedia.org/wiki/Positive-definite_matrix\\\n #Extension_for_non_symmetric_matrices\n is_square: Expect that this operator acts like square [batch] matrices.\n name: A name for this `LinearOperator`. Default is the individual\n operators names joined with `_x_`.\n\n Raises:\n TypeError: If all operators do not have the same `dtype`.\n ValueError: If `operators` is empty.\n \"\"\"\n # Validate operators.\n check_ops.assert_proper_iterable(operators)\n operators = list(operators)\n if not operators:\n raise ValueError(\n \"Expected a list of >=1 operators. Found: %s\" % operators)\n self._operators = operators\n\n # Validate dtype.\n dtype = operators[0].dtype\n for operator in operators:\n if operator.dtype != dtype:\n name_type = (str((o.name, o.dtype)) for o in operators)\n raise TypeError(\n \"Expected all operators to have the same dtype. Found %s\"\n % \" \".join(name_type))\n\n # Auto-set and check hints.\n # A Kronecker product is invertible, if and only if all factors are\n # invertible.\n if all(operator.is_non_singular for operator in operators):\n if is_non_singular is False:\n raise ValueError(\n \"The Kronecker product of non-singular operators is always \"\n \"non-singular.\")\n is_non_singular = True\n\n if all(operator.is_self_adjoint for operator in operators):\n if is_self_adjoint is False:\n raise ValueError(\n \"The Kronecker product of self-adjoint operators is always \"\n \"self-adjoint.\")\n is_self_adjoint = True\n\n # The eigenvalues of a Kronecker product are equal to the products of eigen\n # values of the corresponding factors.\n if all(operator.is_positive_definite for operator in operators):\n if is_positive_definite is False:\n raise ValueError(\"The Kronecker product of positive-definite operators \"\n \"is always positive-definite.\")\n is_positive_definite = True\n\n # Initialization.\n graph_parents = []\n for operator in operators:\n graph_parents.extend(operator.graph_parents)\n\n if name is None:\n name = operators[0].name\n for operator in operators[1:]:\n name += \"_x_\" + operator.name\n with ops.name_scope(name, values=graph_parents):\n super(LinearOperatorKronecker, self).__init__(\n dtype=dtype,\n graph_parents=graph_parents,\n is_non_singular=is_non_singular,\n is_self_adjoint=is_self_adjoint,\n is_positive_definite=is_positive_definite,\n is_square=is_square,\n name=name)\n\n @property\n def operators(self):\n return self._operators\n\n def _shape(self):\n # Get final matrix shape.\n domain_dimension = self.operators[0].domain_dimension\n for operator in self.operators[1:]:\n domain_dimension *= operator.domain_dimension\n\n range_dimension = self.operators[0].range_dimension\n for operator in self.operators[1:]:\n range_dimension *= operator.range_dimension\n\n matrix_shape = tensor_shape.TensorShape([\n range_dimension, domain_dimension])\n\n # Get broadcast batch shape.\n # broadcast_shape checks for compatibility.\n batch_shape = self.operators[0].batch_shape\n for operator in self.operators[1:]:\n batch_shape = common_shapes.broadcast_shape(\n batch_shape, operator.batch_shape)\n\n return batch_shape.concatenate(matrix_shape)\n\n def _shape_tensor(self):\n domain_dimension = self.operators[0].domain_dimension_tensor()\n for operator in self.operators[1:]:\n domain_dimension *= operator.domain_dimension_tensor()\n\n range_dimension = self.operators[0].range_dimension_tensor()\n for operator in self.operators[1:]:\n range_dimension *= operator.range_dimension_tensor()\n\n matrix_shape = [range_dimension, domain_dimension]\n\n # Get broadcast batch shape.\n # broadcast_shape checks for compatibility.\n batch_shape = self.operators[0].batch_shape_tensor()\n for operator in self.operators[1:]:\n batch_shape = array_ops.broadcast_dynamic_shape(\n batch_shape, operator.batch_shape_tensor())\n\n return array_ops.concat((batch_shape, matrix_shape), 0)\n\n def _matmul(self, x, adjoint=False, adjoint_arg=False):\n # Here we heavily rely on Roth's column Lemma [1]:\n # (A x B) * vec X = vec BXA^T,\n # where vec stacks all the columns of the matrix under each other. In our\n # case, x represents a batch of vec X (i.e. we think of x as a batch of\n # column vectors, rather than a matrix). Each member of the batch can be\n # reshaped to a matrix (hence we get a batch of matrices).\n # We can iteratively apply this lemma by noting that if B is a Kronecker\n # product, then we can apply the lemma again.\n\n # [1] W. E. Roth, \"On direct product matrices,\"\n # Bulletin of the American Mathematical Society, vol. 40, pp. 461-468,\n # 1934\n\n # Efficiency\n\n # Naively doing the Kronecker product, by calculating the dense matrix and\n # applying it will can take cubic time in the size of domain_dimension\n # (assuming a square matrix). The other issue is that calculating the dense\n # matrix can be prohibitively expensive, in that it can take a large amount\n # of memory.\n #\n # This implementation avoids this memory blow up by only computing matmuls\n # with the factors. In this way, we don't have to realize the dense matrix.\n # In terms of complexity, if we have Kronecker Factors of size:\n # (n1, n1), (n2, n2), (n3, n3), ... (nJ, nJ), with N = \\prod n_i, and we\n # have as input a [N, M] matrix, the naive approach would take O(N^2 M).\n # With this approach (ignoring reshaping of tensors and transposes for now),\n # the time complexity can be O(M * (\\sum n_i) * N). There is also the\n # benefit of batched multiplication (In this example, the batch size is\n # roughly M * N) so this can be much faster. However, not factored in are\n # the costs of the several transposing of tensors, which can affect cache\n # behavior.\n\n # Below we document the shape manipulation for adjoint=False,\n # adjoint_arg=False, but the general case of different adjoints is still\n # handled.\n\n if adjoint_arg:\n x = linalg.adjoint(x)\n\n # Always add a batch dimension to enable broadcasting to work.\n batch_shape = array_ops.concat(\n [array_ops.ones_like(self.batch_shape_tensor()), [1, 1]], 0)\n x += array_ops.zeros(batch_shape, dtype=x.dtype.base_dtype)\n\n # x has shape [B, R, C], where B represent some number of batch dimensions,\n # R represents the number of rows, and C represents the number of columns.\n # In order to apply Roth's column lemma, we need to operate on a batch of\n # column vectors, so we reshape into a batch of column vectors. We put it\n # at the front to ensure that broadcasting between operators to the batch\n # dimensions B still works.\n output = _rotate_last_dim(x, rotate_right=True)\n\n # Also expand the shape to be [A, C, B, R]. The first dimension will be\n # used to accumulate dimensions from each operator matmul.\n output = output[array_ops.newaxis, ...]\n\n # In this loop, A is going to refer to the value of the accumulated\n # dimension. A = 1 at the start, and will end up being self.range_dimension.\n # V will refer to the last dimension. V = R at the start, and will end up\n # being 1 in the end.\n for operator in self.operators[:-1]:\n # Reshape output from [A, C, B, V] to be\n # [A, C, B, V / op.domain_dimension, op.domain_dimension]\n if adjoint:\n operator_dimension = operator.range_dimension_tensor()\n else:\n operator_dimension = operator.domain_dimension_tensor()\n\n output = _unvec_by(output, operator_dimension)\n\n # We are computing (XA^T) = (AX^T)^T.\n # output has [A, C, B, V / op.domain_dimension, op.domain_dimension],\n # which is being converted to:\n # [A, C, B, V / op.domain_dimension, op.range_dimension]\n output = array_ops.matrix_transpose(output)\n output = operator.matmul(output, adjoint=adjoint, adjoint_arg=False)\n output = array_ops.matrix_transpose(output)\n # Rearrange it to [A * op.range_dimension, C, B, V / op.domain_dimension]\n output = _rotate_last_dim(output, rotate_right=False)\n output = _vec(output)\n output = _rotate_last_dim(output, rotate_right=True)\n\n # After the loop, we will have\n # A = self.range_dimension / op[-1].range_dimension\n # V = op[-1].domain_dimension\n\n # We convert that using matvec to get:\n # [A, C, B, op[-1].range_dimension]\n output = self.operators[-1].matvec(output, adjoint=adjoint)\n # Rearrange shape to be [B1, ... Bn, self.range_dimension, C]\n output = _rotate_last_dim(output, rotate_right=False)\n output = _vec(output)\n output = _rotate_last_dim(output, rotate_right=False)\n\n if x.shape.is_fully_defined():\n column_dim = x.shape[-1]\n broadcast_batch_shape = common_shapes.broadcast_shape(\n x.shape[:-2], self.batch_shape)\n if adjoint:\n matrix_dimensions = [self.domain_dimension, column_dim]\n else:\n matrix_dimensions = [self.range_dimension, column_dim]\n\n output.set_shape(broadcast_batch_shape.concatenate(\n matrix_dimensions))\n\n return output\n\n def _determinant(self):\n # Note that we have |X1 x X2| = |X1| ** n * |X2| ** m, where X1 is an m x m\n # matrix, and X2 is an n x n matrix. We can iteratively apply this property\n # to get the determinant of |X1 x X2 x X3 ...|. If T is the product of the\n # domain dimension of all operators, then we have:\n # |X1 x X2 x X3 ...| =\n # |X1| ** (T / m) * |X2 x X3 ... | ** m =\n # |X1| ** (T / m) * |X2| ** (m * (T / m) / n) * ... =\n # |X1| ** (T / m) * |X2| ** (T / n) * | X3 x X4... | ** (m * n)\n # And by doing induction we have product(|X_i| ** (T / dim(X_i))).\n total = self.domain_dimension_tensor()\n determinant = 1.\n for operator in self.operators:\n determinant *= operator.determinant() ** math_ops.cast(\n total / operator.domain_dimension_tensor(),\n dtype=operator.dtype)\n return determinant\n\n def _log_abs_determinant(self):\n # This will be sum((total / dim(x_i)) * log |X_i|)\n total = self.domain_dimension_tensor()\n log_abs_det = 0.\n for operator in self.operators:\n log_abs_det += operator.log_abs_determinant() * math_ops.cast(\n total / operator.domain_dimension_tensor(),\n dtype=operator.dtype)\n return log_abs_det\n\n def _trace(self):\n # tr(A x B) = tr(A) * tr(B)\n trace = 1.\n for operator in self.operators:\n trace *= operator.trace()\n return trace\n\n def _solve(self, rhs, adjoint=False, adjoint_arg=False):\n # Here we follow the same use of Roth's column lemma as in `matmul`, with\n # the key difference that we replace all `matmul` instances with `solve`.\n # This follows from the property that inv(A x B) = inv(A) x inv(B).\n\n # Below we document the shape manipulation for adjoint=False,\n # adjoint_arg=False, but the general case of different adjoints is still\n # handled.\n\n if adjoint_arg:\n rhs = linalg.adjoint(rhs)\n\n # Always add a batch dimension to enable broadcasting to work.\n batch_shape = array_ops.concat(\n [array_ops.ones_like(self.batch_shape_tensor()), [1, 1]], 0)\n rhs += array_ops.zeros(batch_shape, dtype=rhs.dtype.base_dtype)\n\n # rhs has shape [B, R, C], where B represent some number of batch\n # dimensions,\n # R represents the number of rows, and C represents the number of columns.\n # In order to apply Roth's column lemma, we need to operate on a batch of\n # column vectors, so we reshape into a batch of column vectors. We put it\n # at the front to ensure that broadcasting between operators to the batch\n # dimensions B still works.\n output = _rotate_last_dim(rhs, rotate_right=True)\n\n # Also expand the shape to be [A, C, B, R]. The first dimension will be\n # used to accumulate dimensions from each operator matmul.\n output = output[array_ops.newaxis, ...]\n\n # In this loop, A is going to refer to the value of the accumulated\n # dimension. A = 1 at the start, and will end up being self.range_dimension.\n # V will refer to the last dimension. V = R at the start, and will end up\n # being 1 in the end.\n for operator in self.operators[:-1]:\n # Reshape output from [A, C, B, V] to be\n # [A, C, B, V / op.domain_dimension, op.domain_dimension]\n if adjoint:\n operator_dimension = operator.range_dimension_tensor()\n else:\n operator_dimension = operator.domain_dimension_tensor()\n\n output = _unvec_by(output, operator_dimension)\n\n # We are computing (XA^-1^T) = (A^-1 X^T)^T.\n # output has [A, C, B, V / op.domain_dimension, op.domain_dimension],\n # which is being converted to:\n # [A, C, B, V / op.domain_dimension, op.range_dimension]\n output = array_ops.matrix_transpose(output)\n output = operator.solve(output, adjoint=adjoint, adjoint_arg=False)\n output = array_ops.matrix_transpose(output)\n # Rearrange it to [A * op.range_dimension, C, B, V / op.domain_dimension]\n output = _rotate_last_dim(output, rotate_right=False)\n output = _vec(output)\n output = _rotate_last_dim(output, rotate_right=True)\n\n # After the loop, we will have\n # A = self.range_dimension / op[-1].range_dimension\n # V = op[-1].domain_dimension\n\n # We convert that using matvec to get:\n # [A, C, B, op[-1].range_dimension]\n output = self.operators[-1].solvevec(output, adjoint=adjoint)\n # Rearrange shape to be [B1, ... Bn, self.range_dimension, C]\n output = _rotate_last_dim(output, rotate_right=False)\n output = _vec(output)\n output = _rotate_last_dim(output, rotate_right=False)\n\n if rhs.shape.is_fully_defined():\n column_dim = rhs.shape[-1]\n broadcast_batch_shape = common_shapes.broadcast_shape(\n rhs.shape[:-2], self.batch_shape)\n if adjoint:\n matrix_dimensions = [self.domain_dimension, column_dim]\n else:\n matrix_dimensions = [self.range_dimension, column_dim]\n\n output.set_shape(broadcast_batch_shape.concatenate(\n matrix_dimensions))\n\n return output\n\n def _diag_part(self):\n diag_part = self.operators[0].diag_part()\n for operator in self.operators[1:]:\n diag_part = diag_part[..., :, array_ops.newaxis]\n op_diag_part = operator.diag_part()[..., array_ops.newaxis, :]\n diag_part *= op_diag_part\n diag_part = array_ops.reshape(\n diag_part,\n shape=array_ops.concat(\n [array_ops.shape(diag_part)[:-2], [-1]], axis=0))\n if self.range_dimension > self.domain_dimension:\n diag_dimension = self.domain_dimension\n else:\n diag_dimension = self.range_dimension\n diag_part.set_shape(\n self.batch_shape.concatenate(diag_dimension))\n return diag_part\n\n def _to_dense(self):\n product = self.operators[0].to_dense()\n for operator in self.operators[1:]:\n # Product has shape [B, R1, 1, C1].\n product = product[\n ..., :, array_ops.newaxis, :, array_ops.newaxis]\n # Operator has shape [B, 1, R2, 1, C2].\n op_to_mul = operator.to_dense()[\n ..., array_ops.newaxis, :, array_ops.newaxis, :]\n # This is now [B, R1, R2, C1, C2].\n product *= op_to_mul\n # Now merge together dimensions to get [B, R1 * R2, C1 * C2].\n product = array_ops.reshape(\n product,\n shape=array_ops.concat(\n [array_ops.shape(product)[:-4],\n [array_ops.shape(product)[-4] * array_ops.shape(product)[-3],\n array_ops.shape(product)[-2] * array_ops.shape(product)[-1]]\n ], axis=0))\n product.set_shape(self.shape)\n return product\n\n def _assert_non_singular(self):\n if all(operator.is_square for operator in self.operators):\n asserts = [operator.assert_non_singular() for operator in self.operators]\n return control_flow_ops.group(asserts)\n else:\n raise errors.InvalidArgumentError(\n node_def=None, op=None, message=\"All Kronecker factors must be \"\n \"square for the product to be invertible.\")\n\n def _assert_self_adjoint(self):\n if all(operator.is_square for operator in self.operators):\n asserts = [operator.assert_self_adjoint() for operator in self.operators]\n return control_flow_ops.group(asserts)\n else:\n raise errors.InvalidArgumentError(\n node_def=None, op=None, message=\"All Kronecker factors must be \"\n \"square for the product to be self adjoint.\")\n",
"import numpy as np\nimport requests\nfrom alibi.datasets import fetch_adult\nimport pandas as pd\nimport plotly.graph_objects as go\nfrom IPython.display import display, Markdown, display\n\ndef getFeatures(X,cmap):\n return pd.DataFrame(X).replace(cmap).values.squeeze().tolist()\n\ndef predict(X, name, ds, svc_hostname, cluster_ip):\n formData = {\n 'instances': X\n }\n headers = {}\n headers[\"Host\"] = svc_hostname\n res = requests.post('http://'+cluster_ip+'/v1/models/'+name+':predict', json=formData, headers=headers)\n if res.status_code == 200:\n return ds.target_names[np.array(res.json()[\"predictions\"])[0]]\n else:\n print(\"Failed with \",res.status_code)\n return []\n\ndef explain(X, name, svc_hostname, cluster_ip):\n formData = {\n 'instances': X\n }\n headers = {}\n headers[\"Host\"] = svc_hostname\n res = requests.post('http://'+cluster_ip+'/v1/models/'+name+':explain', json=formData, headers=headers)\n if res.status_code == 200:\n return res.json()\n else:\n print(\"Failed with \",res.status_code)\n return []\n\ndef show_bar(X, labels, title):\n fig = go.Figure(go.Bar(x=X,y=labels,orientation='h',width=[0.5]))\n fig.update_layout(autosize=False,width=700,height=300,\n xaxis=dict(range=[0, 1]),\n title_text=title,\n font=dict(family=\"Courier New, monospace\",size=18,color=\"#7f7f7f\"\n ))\n fig.show()\n\n\ndef show_feature_coverage(exp):\n data = []\n for idx, name in enumerate(exp[\"anchor\"]):\n data.append(go.Bar(name=name, x=[\"coverage\"], y=[exp['raw']['coverage'][idx]]))\n fig = go.Figure(data=data)\n fig.update_layout(yaxis=dict(range=[0, 1]))\n fig.show()\n\ndef show_anchors(names):\n display(Markdown('# Explanation:'))\n display(Markdown('## {}'.format(names)))\n\ndef show_examples(exp,fidx,ds,covered=True):\n if covered:\n cname = 'covered_true'\n display(Markdown(\"## Examples covered by Anchors: {}\".format(exp['anchor'][0:fidx+1])))\n else:\n cname = 'covered_false'\n display(Markdown(\"## Examples not covered by Anchors: {}\".format(exp['anchor'][0:fidx+1])))\n if \"feature_names\" in ds:\n return pd.DataFrame(exp['raw']['examples'][fidx][cname],columns=ds.feature_names)\n else:\n return pd.DataFrame(exp['raw']['examples'][fidx][cname])\n\ndef show_prediction(prediction):\n display(Markdown('## Prediction: {}'.format(prediction)))\n\ndef show_row(X,ds):\n display(pd.DataFrame(X,columns=ds.feature_names))\n\n",
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"A simple example to test the a DistributionStrategy with Estimators.\n\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport tensorflow as tf\n\nfrom tensorflow.python.keras import metrics as metrics_module\n\n\ndef build_model_fn_optimizer():\n \"\"\"Simple model_fn with optimizer.\"\"\"\n # TODO(anjalisridhar): Move this inside the model_fn once OptimizerV2 is\n # done?\n optimizer = tf.train.GradientDescentOptimizer(0.2)\n\n def model_fn(features, labels, mode): # pylint: disable=unused-argument\n \"\"\"model_fn which uses a single unit Dense layer.\"\"\"\n # You can also use the Flatten layer if you want to test a model without any\n # weights.\n layer = tf.layers.Dense(1, use_bias=True)\n logits = layer(features)\n\n if mode == tf.estimator.ModeKeys.PREDICT:\n predictions = {\"logits\": logits}\n return tf.estimator.EstimatorSpec(mode, predictions=predictions)\n\n def loss_fn():\n y = tf.reshape(logits, []) - tf.constant(1.)\n return y * y\n\n if mode == tf.estimator.ModeKeys.EVAL:\n acc_obj = metrics_module.BinaryAccuracy()\n acc_obj.update_state(labels, labels)\n return tf.estimator.EstimatorSpec(\n mode, loss=loss_fn(), eval_metric_ops={\"Accuracy\": acc_obj})\n\n assert mode == tf.estimator.ModeKeys.TRAIN\n\n global_step = tf.train.get_global_step()\n train_op = optimizer.minimize(loss_fn(), global_step=global_step)\n return tf.estimator.EstimatorSpec(mode, loss=loss_fn(), train_op=train_op)\n\n return model_fn\n\n\ndef main(_):\n distribution = tf.contrib.distribute.MirroredStrategy(\n [\"/device:GPU:0\", \"/device:GPU:1\"])\n config = tf.estimator.RunConfig(train_distribute=distribution,\n eval_distribute=distribution)\n # Since there are 2 devices and 10 samples, we set steps=5.\n steps = 5\n\n def train_input_fn():\n features = tf.data.Dataset.from_tensors([[1.]]).repeat(10)\n labels = tf.data.Dataset.from_tensors([1.]).repeat(10)\n return tf.data.Dataset.zip((features, labels))\n\n estimator = tf.estimator.Estimator(\n model_fn=build_model_fn_optimizer(), config=config)\n estimator.train(input_fn=train_input_fn, steps=steps)\n\n def eval_input_fn():\n features = tf.data.Dataset.from_tensors([[1.]]).repeat(10)\n labels = tf.data.Dataset.from_tensors([1.]).repeat(10)\n return tf.data.Dataset.zip((features, labels))\n\n eval_result = estimator.evaluate(input_fn=eval_input_fn, steps=steps)\n print(\"Eval result: {}\".format(eval_result))\n assert eval_result[\"Accuracy\"] == 1.0\n\n def predict_input_fn():\n predict_features = tf.data.Dataset.from_tensors([[1.]]).repeat(10)\n return predict_features\n\n predictions = estimator.predict(input_fn=predict_input_fn)\n # TODO(anjalsridhar): This returns a generator object, figure out how to get\n # meaningful results here.\n print(\"Prediction results: {}\".format(predictions))\n\n\nif __name__ == \"__main__\":\n tf.app.run()\n",
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Tests for sparse ops.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom absl.testing import parameterized\nimport numpy as np\n\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import sparse_ops\nfrom tensorflow.python.platform import googletest\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass SparseOpsTest(test_util.TensorFlowTestCase, parameterized.TestCase):\n\n def testSparseEye(self):\n def test_one(n, m, as_tensors):\n expected = np.eye(n, m)\n if as_tensors:\n m = constant_op.constant(m)\n n = constant_op.constant(n)\n s = sparse_ops.sparse_eye(n, m)\n d = sparse_ops.sparse_to_dense(s.indices, s.dense_shape, s.values)\n self.assertAllEqual(self.evaluate(d), expected)\n\n for n in range(2, 10, 2):\n for m in range(2, 10, 2):\n # Test with n and m as both constants and tensors.\n test_one(n, m, True)\n test_one(n, m, False)\n\n def testSparseExpandDims(self):\n for rank in range(1, 4):\n # Create a dummy input. When rank=3, shape=[2, 4, 6].\n shape = np.arange(1, rank + 1) * 2\n before = np.arange(np.prod(shape)).reshape(shape)\n\n # Make entries sparse.\n before *= np.random.binomial(1, .2, before.shape)\n dense_shape = before.shape\n indices = np.array(np.where(before)).T\n values = before[before != 0]\n\n # Try every possible valid value of axis.\n for axis in range(-rank - 1, rank):\n expected_after = np.expand_dims(before, axis)\n\n for axis_as_tensor in [False, True]:\n dense_shape_t = constant_op.constant(dense_shape, dtype=dtypes.int64)\n indices_t = constant_op.constant(indices)\n values_t = constant_op.constant(values)\n before_t = sparse_tensor.SparseTensor(\n indices=indices_t, values=values_t, dense_shape=dense_shape_t)\n\n if axis_as_tensor:\n axis = constant_op.constant(axis)\n\n s = sparse_ops.sparse_expand_dims(before_t, axis)\n d = sparse_ops.sparse_to_dense(s.indices, s.dense_shape, s.values)\n self.assertAllEqual(self.evaluate(d), expected_after)\n\n @parameterized.parameters([\n (math_ops.abs, [1.0, -1.0, 3.0, -4.0], [1.0, 1.0, 3.0, 4.0]),\n (math_ops.negative, [1.0, -1.0, 3.0, -4.0], [-1.0, 1.0, -3.0, 4.0]),\n (math_ops.sign, [3.0, -2.0, 0.0, -4.0], [1.0, -1.0, 0.0, -1.0]),\n (math_ops.square, [1.0, -1.0, 3.0, -4.0], [1.0, 1.0, 9.0, 16.0]),\n ])\n def testUnarySparseDispatch(self, op, values, expected):\n st = sparse_tensor.SparseTensor(\n indices=[[0, 0], [0, 1], [2, 0], [2, 4]],\n values=values,\n dense_shape=[3, 6])\n result = op(st)\n result_value = self.evaluate(result)\n self.assertAllEqual(result_value.indices, st.indices)\n self.assertAllEqual(result_value.values, expected)\n self.assertAllEqual(result_value.dense_shape, st.dense_shape)\n\n\nif __name__ == '__main__':\n googletest.main()\n",
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Benchmarks for `tf.data.experimental.CsvDataset`.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport string\nimport tempfile\nimport time\n\nimport numpy as np\n\nfrom tensorflow.python.client import session\nfrom tensorflow.python.data.experimental.ops import readers\nfrom tensorflow.python.data.ops import dataset_ops\nfrom tensorflow.python.data.ops import readers as core_readers\nfrom tensorflow.python.ops import parsing_ops\nfrom tensorflow.python.platform import gfile\nfrom tensorflow.python.platform import googletest\nfrom tensorflow.python.platform import test\n\n\nclass CsvDatasetBenchmark(test.Benchmark):\n \"\"\"Benchmarks for `tf.data.experimental.CsvDataset`.\"\"\"\n\n FLOAT_VAL = '1.23456E12'\n STR_VAL = string.ascii_letters * 10\n\n def _setUp(self, str_val):\n # Since this isn't test.TestCase, have to manually create a test dir\n gfile.MakeDirs(googletest.GetTempDir())\n self._temp_dir = tempfile.mkdtemp(dir=googletest.GetTempDir())\n\n self._num_cols = [4, 64, 256]\n self._num_per_iter = 5000\n self._filenames = []\n for n in self._num_cols:\n fn = os.path.join(self._temp_dir, 'file%d.csv' % n)\n with open(fn, 'wb') as f:\n # Just write 100 rows and use `repeat`... Assumes the cost\n # of creating an iterator is not significant\n row = ','.join([str_val for _ in range(n)])\n f.write('\\n'.join([row for _ in range(100)]))\n self._filenames.append(fn)\n\n def _tearDown(self):\n gfile.DeleteRecursively(self._temp_dir)\n\n def _runBenchmark(self, dataset, num_cols, prefix):\n dataset = dataset.skip(self._num_per_iter - 1)\n deltas = []\n for _ in range(10):\n next_element = dataset_ops.make_one_shot_iterator(dataset).get_next()\n with session.Session() as sess:\n start = time.time()\n # NOTE: This depends on the underlying implementation of skip, to have\n # the net effect of calling `GetNext` num_per_iter times on the\n # input dataset. We do it this way (instead of a python for loop, or\n # batching N inputs in one iter) so that the overhead from session.run\n # or batch doesn't dominate. If we eventually optimize skip, this has\n # to change.\n sess.run(next_element)\n end = time.time()\n deltas.append(end - start)\n # Median wall time per CSV record read and decoded\n median_wall_time = np.median(deltas) / self._num_per_iter\n print('%s num_cols: %d Median wall time: %f' % (prefix, num_cols,\n median_wall_time))\n self.report_benchmark(\n iters=self._num_per_iter,\n wall_time=median_wall_time,\n name='%s_with_cols_%d' % (prefix, num_cols))\n\n def benchmarkMapWithFloats(self):\n self._setUp(self.FLOAT_VAL)\n for i in range(len(self._filenames)):\n num_cols = self._num_cols[i]\n kwargs = {'record_defaults': [[0.0]] * num_cols}\n dataset = core_readers.TextLineDataset(self._filenames[i]).repeat()\n dataset = dataset.map(lambda l: parsing_ops.decode_csv(l, **kwargs)) # pylint: disable=cell-var-from-loop\n self._runBenchmark(dataset, num_cols, 'csv_float_map_decode_csv')\n self._tearDown()\n\n def benchmarkMapWithStrings(self):\n self._setUp(self.STR_VAL)\n for i in range(len(self._filenames)):\n num_cols = self._num_cols[i]\n kwargs = {'record_defaults': [['']] * num_cols}\n dataset = core_readers.TextLineDataset(self._filenames[i]).repeat()\n dataset = dataset.map(lambda l: parsing_ops.decode_csv(l, **kwargs)) # pylint: disable=cell-var-from-loop\n self._runBenchmark(dataset, num_cols, 'csv_strings_map_decode_csv')\n self._tearDown()\n\n def benchmarkCsvDatasetWithFloats(self):\n self._setUp(self.FLOAT_VAL)\n for i in range(len(self._filenames)):\n num_cols = self._num_cols[i]\n kwargs = {'record_defaults': [[0.0]] * num_cols}\n dataset = core_readers.TextLineDataset(self._filenames[i]).repeat()\n dataset = readers.CsvDataset(self._filenames[i], **kwargs).repeat() # pylint: disable=cell-var-from-loop\n self._runBenchmark(dataset, num_cols, 'csv_float_fused_dataset')\n self._tearDown()\n\n def benchmarkCsvDatasetWithStrings(self):\n self._setUp(self.STR_VAL)\n for i in range(len(self._filenames)):\n num_cols = self._num_cols[i]\n kwargs = {'record_defaults': [['']] * num_cols}\n dataset = core_readers.TextLineDataset(self._filenames[i]).repeat()\n dataset = readers.CsvDataset(self._filenames[i], **kwargs).repeat() # pylint: disable=cell-var-from-loop\n self._runBenchmark(dataset, num_cols, 'csv_strings_fused_dataset')\n self._tearDown()\n\nif __name__ == '__main__':\n test.main()\n",
"# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Tests for control_flow module.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom tensorflow.python.autograph.converters import control_flow\nfrom tensorflow.python.autograph.core import converter_testing\nfrom tensorflow.python.autograph.pyct import transformer\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.platform import test\n\n\nclass ControlFlowTest(converter_testing.TestCase):\n\n def assertTransformedResult(self, test_fn, inputs, expected):\n if not isinstance(inputs, tuple):\n inputs = (inputs,)\n with self.converted(test_fn, control_flow, {},\n constant_op.constant) as result:\n with self.cached_session() as sess:\n self.assertEqual(sess.run(result.test_fn(*inputs)), expected)\n\n @test_util.run_deprecated_v1\n def test_while_basic(self):\n\n def test_fn(n):\n i = 0\n s = 0\n while i < n:\n s += i\n i += 1\n return s, i, n\n\n self.assertTransformedResult(test_fn, constant_op.constant(5), (10, 5, 5))\n\n @test_util.run_deprecated_v1\n def test_while_nested(self):\n\n def test_fn(n):\n i = 0\n j = 0\n s = 0\n while i < n:\n while j < i:\n j += 3\n u = i + j # 'u' is not defined within the inner loop\n s += u\n i += 1\n j = 0\n return s, i, j, n\n\n self.assertTransformedResult(test_fn, constant_op.constant(5),\n (25, 5, 0, 5))\n\n @test_util.run_deprecated_v1\n def test_while_single_output(self):\n\n def test_fn(n):\n while n > 0:\n n -= 1\n return n\n\n self.assertTransformedResult(test_fn, constant_op.constant(5), 0)\n\n def test_while_variable_defined_in_body(self):\n def bad_while_loop(n):\n while n > 0:\n n -= 1\n s = n\n return s\n\n node, ctx = self.prepare(bad_while_loop, {})\n with self.assertRaises(NameError):\n control_flow.transform(node, ctx)\n\n @test_util.run_deprecated_v1\n def test_if_basic(self):\n\n def test_fn(n):\n a = 0\n b = 0\n if n > 0:\n a = -n\n else:\n b = 2 * n\n return a, b\n\n self.assertTransformedResult(test_fn, constant_op.constant(1), (-1, 0))\n self.assertTransformedResult(test_fn, constant_op.constant(-1), (0, -2))\n\n @test_util.run_deprecated_v1\n def test_if_complex_outputs(self):\n\n class TestClass(object):\n\n def __init__(self, a, b):\n self.a = a\n self.b = b\n\n def test_fn(n, obj):\n obj.a = 0\n obj.b = 0\n if n > 0:\n obj.a = -n\n else:\n obj.b = 2 * n\n return obj\n\n with self.converted(test_fn, control_flow, {}) as result:\n with self.cached_session() as sess:\n res_obj = result.test_fn(constant_op.constant(1), TestClass(0, 0))\n self.assertEqual(sess.run((res_obj.a, res_obj.b)), (-1, 0))\n res_obj = result.test_fn(constant_op.constant(-1), TestClass(0, 0))\n self.assertEqual(sess.run((res_obj.a, res_obj.b)), (0, -2))\n\n @test_util.run_deprecated_v1\n def test_if_single_output(self):\n\n def test_fn(n):\n if n > 0:\n n = -n\n return n\n\n self.assertTransformedResult(test_fn, constant_op.constant(1), -1)\n\n @test_util.run_deprecated_v1\n def test_if_semi(self):\n\n def test_fn(n):\n if n > 0:\n n = 3\n return n\n\n self.assertTransformedResult(test_fn, constant_op.constant(2), 3)\n self.assertTransformedResult(test_fn, constant_op.constant(-3), -3)\n\n @test_util.run_deprecated_v1\n def test_if_local_var(self):\n\n def test_fn(n):\n if n > 0:\n b = 4\n n = b + 1\n return n\n\n self.assertTransformedResult(test_fn, constant_op.constant(1), 5)\n self.assertTransformedResult(test_fn, constant_op.constant(-1), -1)\n\n @test_util.run_deprecated_v1\n def test_if_no_outputs(self):\n\n def test_fn(n):\n if n > 0:\n b = 4 # pylint:disable=unused-variable\n return n\n\n # Without side effect guards, the if statement will stage a cond,\n # but that will be pruned at execution.\n self.assertTransformedResult(test_fn, constant_op.constant(1), 1)\n self.assertTransformedResult(test_fn, constant_op.constant(-1), -1)\n\n def test_if_imbalanced_outputs(self):\n\n def test_fn(n):\n if n > 0:\n b = 4\n return b\n\n node, ctx = self.prepare(test_fn, {})\n with self.assertRaises(transformer.AutographParseError):\n control_flow.transform(node, ctx)\n\n @test_util.run_deprecated_v1\n def test_simple_for(self):\n\n def test_fn(l):\n s1 = 0\n s2 = 0\n for e in l:\n s1 += e\n s2 += e * e\n return s1, s2\n\n self.assertTransformedResult(test_fn, constant_op.constant([1, 3]), (4, 10))\n empty_vector = constant_op.constant([], shape=(0,), dtype=dtypes.int32)\n self.assertTransformedResult(test_fn, empty_vector, (0, 0))\n\n @test_util.run_deprecated_v1\n def test_for_single_output(self):\n\n def test_fn(l):\n s = 0\n for e in l:\n s += e\n return s\n\n self.assertTransformedResult(test_fn, constant_op.constant([1, 3]), 4)\n empty_vector = constant_op.constant([], shape=(0,), dtype=dtypes.int32)\n self.assertTransformedResult(test_fn, empty_vector, 0)\n\n def test_for_iterated_expression(self):\n\n eval_count = [0]\n\n def count_evals(x):\n eval_count[0] += 1\n return x\n\n def test_fn(n):\n s = 0\n for e in count_evals(range(n)):\n s += e\n return s\n\n ns = {'count_evals': count_evals}\n node, ctx = self.prepare(test_fn, ns)\n node = control_flow.transform(node, ctx)\n\n with self.compiled(node, ns) as result:\n self.assertEqual(result.test_fn(5), 10)\n self.assertEqual(eval_count[0], 1)\n\n def test_for_variable_defined_in_body(self):\n def bad_for_loop(n):\n for i in range(n):\n s = i\n return s\n\n node, ctx = self.prepare(bad_for_loop, {})\n with self.assertRaises(NameError):\n control_flow.transform(node, ctx)\n\n @test_util.run_deprecated_v1\n def test_for_tuple_unpacking(self):\n def test_fn(x_list):\n z = tf.constant(0) # pylint:disable=undefined-variable\n for i, x in enumerate(x_list):\n z = z + x + i\n return z\n\n self.assertTransformedResult(test_fn, [3, 3], 7)\nif __name__ == '__main__':\n test.main()\n",
"# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Tests for `tf.data.Dataset.take()`.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\n\nfrom tensorflow.python.data.kernel_tests import test_base\nfrom tensorflow.python.data.ops import dataset_ops\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.platform import test\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass TakeTest(test_base.DatasetTestBase):\n\n def testTakeTensorDataset(self):\n components = (np.arange(10),)\n\n def do_test(count):\n dataset = dataset_ops.Dataset.from_tensor_slices(components).take(count)\n self.assertEqual([c.shape[1:] for c in components],\n [shape for shape in dataset.output_shapes])\n num_output = min(count, 10) if count != -1 else 10\n self.assertDatasetProduces(\n dataset, [tuple(components[0][i:i + 1]) for i in range(num_output)])\n\n # Take fewer than input size\n do_test(4)\n\n # Take more than input size\n do_test(25)\n\n # Take all of input\n do_test(-1)\n\n # Take nothing\n do_test(0)\n\nif __name__ == \"__main__\":\n test.main()\n"
] |
[
[
"tensorflow.python.ops.array_ops.matrix_transpose",
"tensorflow.python.framework.tensor_shape.TensorShape",
"tensorflow.python.framework.errors.InvalidArgumentError",
"tensorflow.python.ops.check_ops.assert_proper_iterable",
"tensorflow.python.framework.common_shapes.broadcast_shape",
"tensorflow.python.ops.linalg.linalg_impl.adjoint",
"tensorflow.python.ops.control_flow_ops.group",
"tensorflow.python.ops.array_ops.concat",
"tensorflow.python.ops.math_ops.range",
"tensorflow.python.ops.array_ops.zeros",
"tensorflow.python.ops.array_ops.transpose",
"tensorflow.python.framework.ops.name_scope",
"tensorflow.python.ops.array_ops.shape",
"tensorflow.python.util.tf_export.tf_export",
"tensorflow.python.ops.array_ops.rank"
],
[
"pandas.DataFrame"
],
[
"tensorflow.contrib.distribute.MirroredStrategy",
"tensorflow.python.keras.metrics.BinaryAccuracy",
"tensorflow.estimator.EstimatorSpec",
"tensorflow.layers.Dense",
"tensorflow.data.Dataset.from_tensors",
"tensorflow.reshape",
"tensorflow.estimator.RunConfig",
"tensorflow.constant",
"tensorflow.app.run",
"tensorflow.data.Dataset.zip",
"tensorflow.train.get_global_step",
"tensorflow.train.GradientDescentOptimizer"
],
[
"tensorflow.python.ops.sparse_ops.sparse_eye",
"tensorflow.python.ops.sparse_ops.sparse_expand_dims",
"numpy.random.binomial",
"tensorflow.python.platform.googletest.main",
"tensorflow.python.ops.sparse_ops.sparse_to_dense",
"tensorflow.python.framework.constant_op.constant",
"numpy.eye",
"numpy.where",
"numpy.prod",
"numpy.arange",
"numpy.expand_dims",
"tensorflow.python.framework.sparse_tensor.SparseTensor"
],
[
"tensorflow.python.platform.googletest.GetTempDir",
"tensorflow.python.ops.parsing_ops.decode_csv",
"numpy.median",
"tensorflow.python.data.ops.readers.TextLineDataset",
"tensorflow.python.client.session.Session",
"tensorflow.python.platform.gfile.DeleteRecursively",
"tensorflow.python.data.ops.dataset_ops.make_one_shot_iterator",
"tensorflow.python.platform.test.main",
"tensorflow.python.data.experimental.ops.readers.CsvDataset"
],
[
"tensorflow.python.autograph.converters.control_flow.transform",
"tensorflow.python.platform.test.main",
"tensorflow.python.framework.constant_op.constant"
],
[
"tensorflow.python.platform.test.main",
"numpy.arange",
"tensorflow.python.data.ops.dataset_ops.Dataset.from_tensor_slices"
]
] |
dshahrokhian/handtracking
|
[
"1003bd5e7a087952f777f04420d0c9785c549bb7"
] |
[
"detect_multi_threaded.py"
] |
[
"from utils import detector_utils as detector_utils \nimport cv2\nimport tensorflow as tf\nimport multiprocessing\nfrom multiprocessing import Queue, Pool\nimport time\nfrom utils.detector_utils import WebcamVideoStream\nimport datetime\nimport argparse\n\n\nframe_processed = 0\nscore_thresh = 0.2\n\n# Create a worker thread that loads graph and\n# does detection on images in an input queue and puts it on an output queue\n\ndef worker(input_q, output_q, cap_params, frame_processed):\n print(\">> loading frozen model for worker\")\n detection_graph, sess = detector_utils.load_inference_graph()\n sess = tf.Session(graph=detection_graph)\n while True:\n #print(\"> ===== in worker loop, frame \", frame_processed)\n frame = input_q.get()\n if (frame is not None):\n # actual detection\n boxes, scores = detector_utils.detect_objects(\n frame, detection_graph, sess)\n # draw bounding boxes\n detector_utils.draw_box_on_image(\n cap_params['num_hands_detect'], cap_params[\"score_thresh\"], scores, boxes, cap_params['im_width'], cap_params['im_height'], frame)\n # add frame annotated with bounding box to queue\n output_q.put(frame)\n frame_processed += 1\n else:\n output_q.put(frame)\n sess.close()\n\n\nif __name__ == '__main__':\n\n parser = argparse.ArgumentParser()\n parser.add_argument('-src', '--source', dest='video_source', type=int,\n default=0, help='Device index of the camera.')\n parser.add_argument('-nhands', '--num_hands', dest='num_hands', type=int,\n default=2, help='Max number of hands to detect.')\n parser.add_argument('-fps', '--fps', dest='fps', type=int,\n default=1, help='Show FPS on detection/display visualization')\n parser.add_argument('-wd', '--width', dest='width', type=int,\n default=300, help='Width of the frames in the video stream.')\n parser.add_argument('-ht', '--height', dest='height', type=int,\n default=200, help='Height of the frames in the video stream.')\n parser.add_argument('-ds', '--display', dest='display', type=int,\n default=1, help='Display the detected images using OpenCV. This reduces FPS')\n parser.add_argument('-num-w', '--num-workers', dest='num_workers', type=int,\n default=4, help='Number of workers.')\n parser.add_argument('-q-size', '--queue-size', dest='queue_size', type=int,\n default=5, help='Size of the queue.')\n args = parser.parse_args()\n\n input_q = Queue(maxsize=args.queue_size)\n output_q = Queue(maxsize=args.queue_size)\n\n video_capture = WebcamVideoStream(src=args.video_source,\n width=args.width,\n height=args.height).start()\n\n cap_params = {}\n frame_processed = 0\n cap_params['im_width'], cap_params['im_height'] = video_capture.size()\n cap_params['score_thresh'] = score_thresh\n\n # max number of hands we want to detect/track\n cap_params['num_hands_detect'] = args.num_hands\n\n print(cap_params, args)\n\n # spin up workers to paralleize detection.\n pool = Pool(args.num_workers, worker,\n (input_q, output_q, cap_params, frame_processed))\n\n start_time = datetime.datetime.now()\n num_frames = 0\n fps = 0\n index = 0\n\n cv2.namedWindow('Multi-Threaded Detection', cv2.WINDOW_NORMAL)\n\n while True:\n frame = video_capture.read()\n frame = cv2.flip(frame, 1)\n index += 1\n\n input_q.put(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))\n output_frame = output_q.get()\n\n output_frame = cv2.cvtColor(output_frame, cv2.COLOR_RGB2BGR)\n\n elapsed_time = (datetime.datetime.now() -\n start_time).total_seconds()\n num_frames += 1\n fps = num_frames / elapsed_time\n # print(\"frame \", index, num_frames, elapsed_time, fps)\n\n if (output_frame is not None):\n if (args.display > 0):\n if (args.fps > 0):\n detector_utils.draw_fps_on_image(\n \"FPS : \" + str(int(fps)), output_frame)\n cv2.imshow('Multi-Threaded Detection', output_frame)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n else:\n if (num_frames == 400):\n num_frames = 0\n start_time = datetime.datetime.now()\n else:\n print(\"frames processed: \", index,\n \"elapsed time: \", elapsed_time, \"fps: \", str(int(fps)))\n else:\n # print(\"video end\")\n break\n elapsed_time = (datetime.datetime.now() -\n start_time).total_seconds()\n fps = num_frames / elapsed_time\n print(\"fps\", fps)\n pool.terminate()\n video_capture.stop()\n cv2.destroyAllWindows()\n"
] |
[
[
"tensorflow.Session"
]
] |
tmoopenn/atari-representation-learning
|
[
"bd5628f77fb4ff421077e74200ebd7b386b87f7c"
] |
[
"atariari/methods/utils.py"
] |
[
"import argparse\nimport copy\nimport os\nimport subprocess\n\nimport torch\nimport numpy as np\nfrom sklearn.metrics import f1_score as compute_f1_score\nfrom a2c_ppo_acktr.envs import make_vec_envs\nfrom a2c_ppo_acktr.utils import get_vec_normalize\nfrom collections import defaultdict\n\n# methods that need encoder trained before\ntrain_encoder_methods = ['cpc', 'jsd-stdim', 'vae', \"naff\", \"infonce-stdim\", \"global-infonce-stdim\",\n \"global-local-infonce-stdim\", \"dim\"]\nprobe_only_methods = [\"supervised\", \"random-cnn\", \"majority\", \"pretrained-rl-agent\"]\n\n\ndef get_argparser():\n parser = argparse.ArgumentParser()\n parser.add_argument('--env-name', default='MontezumaRevengeNoFrameskip-v4',\n help='environment to train on (default: MontezumaRevengeNoFrameskip-v4)')\n parser.add_argument('--num-frame-stack', type=int, default=1,\n help='Number of frames to stack for a state')\n parser.add_argument('--no-downsample', action='store_true', default=True,\n help='Whether to use a linear classifier')\n parser.add_argument('--pretraining-steps', type=int, default=100000,\n help='Number of steps to pretrain representations (default: 100000)')\n parser.add_argument('--probe-steps', type=int, default=50000,\n help='Number of steps to train probes (default: 30000 )')\n # parser.add_argument('--probe-test-steps', type=int, default=15000,\n # help='Number of steps to train probes (default: 15000 )')\n parser.add_argument('--num-processes', type=int, default=8,\n help='Number of parallel environments to collect samples from (default: 8)')\n parser.add_argument('--method', type=str, default='infonce-stdim',\n choices=train_encoder_methods + probe_only_methods,\n help='Method to use for training representations (default: infonce-stdim)')\n parser.add_argument('--linear', action='store_true', default=True,\n help='Whether to use a linear classifier')\n parser.add_argument('--use_multiple_predictors', action='store_true', default=False,\n help='Whether to use multiple linear classifiers in the contrastive loss')\n\n parser.add_argument('--lr', type=float, default=3e-4,\n help='Learning Rate foe learning representations (default: 5e-4)')\n parser.add_argument('--batch-size', type=int, default=64,\n help='Mini-Batch Size (default: 64)')\n parser.add_argument('--epochs', type=int, default=100,\n help='Number of epochs for (default: 100)')\n parser.add_argument('--cuda-id', type=int, default=0,\n help='CUDA device index')\n parser.add_argument('--seed', type=int, default=42,\n help='Random seed to use')\n parser.add_argument('--encoder-type', type=str, default=\"Nature\", choices=[\"Impala\", \"Nature\"],\n help='Encoder type (Impala or Nature)')\n parser.add_argument('--feature-size', type=int, default=256,\n help='Size of features')\n parser.add_argument(\"--patience\", type=int, default=15)\n parser.add_argument(\"--entropy-threshold\", type=float, default=0.6)\n parser.add_argument(\"--color\", action='store_true', default=False)\n parser.add_argument(\"--end-with-relu\", action='store_true', default=False)\n parser.add_argument(\"--wandb-proj\", type=str, default=\"atari-reps\")\n parser.add_argument(\"--wandb-entity\", type=str, default=None)\n parser.add_argument(\"--num_rew_evals\", type=int, default=10)\n # rl-probe specific arguments\n parser.add_argument(\"--checkpoint-index\", type=int, default=-1)\n\n # naff-specific arguments\n parser.add_argument(\"--naff_fc_size\", type=int, default=2048,\n help=\"fully connected layer width for naff\")\n parser.add_argument(\"--pred_offset\", type=int, default=1,\n help=\"how many steps in future to predict\")\n # CPC-specific arguments\n parser.add_argument('--sequence_length', type=int, default=100,\n help='Sequence length.')\n parser.add_argument('--steps_start', type=int, default=0,\n help='Number of immediate future steps to ignore.')\n parser.add_argument('--steps_end', type=int, default=99,\n help='Number of future steps to predict.')\n parser.add_argument('--steps_step', type=int, default=4,\n help='Skip every these many frames.')\n parser.add_argument('--gru_size', type=int, default=256,\n help='Hidden size of the GRU layers.')\n parser.add_argument('--gru_layers', type=int, default=2,\n help='Number of GRU layers.')\n parser.add_argument(\"--collect-mode\", type=str, choices=[\"random_agent\", \"pretrained_ppo\"],\n default=\"random_agent\")\n\n parser.add_argument(\"--beta\", default=1.0)\n # probe arguments\n parser.add_argument(\"--weights-path\", type=str, default=\"None\")\n parser.add_argument(\"--train-encoder\", action='store_true', default=True)\n parser.add_argument('--probe-lr', type=float, default=3e-4)\n parser.add_argument(\"--probe-collect-mode\", type=str, choices=[\"random_agent\", \"pretrained_ppo\"],\n default=\"random_agent\")\n parser.add_argument('--num-runs', type=int, default=1)\n return parser\n\n\ndef set_seeds(seed):\n torch.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n np.random.seed(seed)\n\n if torch.cuda.is_available():\n torch.backends.cudnn.benchmark = False\n torch.backends.cudnn.deterministic = True\n\n\ndef calculate_accuracy(preds, y):\n preds = preds >= 0.5\n labels = y >= 0.5\n acc = preds.eq(labels).sum().float() / labels.numel()\n return acc\n\n\ndef calculate_multiclass_f1_score(preds, labels):\n preds = torch.argmax(preds, dim=1).detach().numpy()\n labels = labels.numpy()\n f1score = compute_f1_score(labels, preds, average=\"weighted\")\n return f1score\n\n\ndef calculate_multiclass_accuracy(preds, labels):\n preds = torch.argmax(preds, dim=1)\n acc = float(torch.sum(torch.eq(labels, preds)).data) / labels.size(0)\n return acc\n\n\ndef save_model(model, envs, save_dir, model_name, use_cuda):\n save_path = os.path.join(save_dir)\n try:\n os.makedirs(save_path)\n except OSError:\n pass\n\n # A really ugly way to save a model to CPU\n save_model = model\n if use_cuda:\n save_model = copy.deepcopy(model).cpu()\n\n save_model = [save_model,\n getattr(get_vec_normalize(envs), 'ob_rms', None)]\n\n torch.save(save_model, os.path.join(save_path, model_name + \".pt\"))\n\n\ndef evaluate_policy(actor_critic, envs, args, eval_log_dir, device):\n eval_envs = make_vec_envs(\n args.env_name, args.seed + args.num_processes, args.num_processes,\n args.gamma, eval_log_dir, args.add_timestep, device, True)\n\n vec_norm = get_vec_normalize(eval_envs)\n if vec_norm is not None:\n vec_norm.eval()\n vec_norm.ob_rms = get_vec_normalize(envs).ob_rms\n\n eval_episode_rewards = []\n\n obs = eval_envs.reset()\n eval_recurrent_hidden_states = torch.zeros(args.num_processes,\n actor_critic.recurrent_hidden_state_size, device=device)\n eval_masks = torch.zeros(args.num_processes, 1, device=device)\n\n while len(eval_episode_rewards) < 10:\n with torch.no_grad():\n _, action, _, eval_recurrent_hidden_states = actor_critic.act(\n obs, eval_recurrent_hidden_states, eval_masks, deterministic=True)\n\n # Obser reward and next obs\n obs, reward, done, infos = eval_envs.step(action)\n\n eval_masks = torch.FloatTensor([[0.0] if done_ else [1.0]\n for done_ in done])\n for info in infos:\n if 'episode' in info.keys():\n eval_episode_rewards.append(info['episode']['r'])\n print(\" Evaluation using {} episodes: mean reward {:.5f}\\n\".\n format(len(eval_episode_rewards),\n np.mean(eval_episode_rewards)))\n eval_envs.close()\n return eval_episode_rewards\n\n\ndef generate_video():\n os.chdir(\"act_maps\")\n subprocess.call([\n 'ffmpeg', '-framerate', '8', '-i', 'file%02d.png', '-r', '30', '-pix_fmt', 'yuv420p',\n 'video_name.mp4'\n ])\n\n\nclass appendabledict(defaultdict):\n def __init__(self, type_=list, *args, **kwargs):\n self.type_ = type_\n super().__init__(type_, *args, **kwargs)\n\n # def map_(self, func):\n # for k, v in self.items():\n # self.__setitem__(k, func(v))\n\n def subslice(self, slice_):\n \"\"\"indexes every value in the dict according to a specified slice\n\n Parameters\n ----------\n slice : int or slice type\n An indexing slice , e.g., ``slice(2, 20, 2)`` or ``2``.\n\n\n Returns\n -------\n sliced_dict : dict (not appendabledict type!)\n A dictionary with each value from this object's dictionary, but the value is sliced according to slice_\n e.g. if this dictionary has {a:[1,2,3,4], b:[5,6,7,8]}, then self.subslice(2) returns {a:3,b:7}\n self.subslice(slice(1,3)) returns {a:[2,3], b:[6,7]}\n\n \"\"\"\n sliced_dict = {}\n for k, v in self.items():\n sliced_dict[k] = v[slice_]\n return sliced_dict\n\n def append_update(self, other_dict):\n \"\"\"appends current dict's values with values from other_dict\n\n Parameters\n ----------\n other_dict : dict\n A dictionary that you want to append to this dictionary\n\n\n Returns\n -------\n Nothing. The side effect is this dict's values change\n\n \"\"\"\n for k, v in other_dict.items():\n self.__getitem__(k).append(v)\n\n\n# Thanks Bjarten! (https://github.com/Bjarten/early-stopping-pytorch)\nclass EarlyStopping(object):\n \"\"\"Early stops the training if validation loss doesn't improve after a given patience.\"\"\"\n\n def __init__(self, patience=7, verbose=False, wandb=None, name=\"\"):\n \"\"\"\n Args:\n patience (int): How long to wait after last time validation loss improved.\n Default: 7\n verbose (bool): If True, prints a message for each validation loss improvement.\n Default: False\n \"\"\"\n self.patience = patience\n self.verbose = verbose\n self.counter = 0\n self.best_score = None\n self.early_stop = False\n self.val_acc_max = 0.\n self.name = name\n self.wandb = wandb\n\n def __call__(self, val_acc, model):\n\n score = val_acc\n\n if self.best_score is None:\n self.best_score = score\n self.save_checkpoint(val_acc, model)\n elif score <= self.best_score:\n self.counter += 1\n print(f'EarlyStopping for {self.name} counter: {self.counter} out of {self.patience}')\n if self.counter >= self.patience:\n self.early_stop = True\n print(f'{self.name} has stopped')\n\n else:\n self.best_score = score\n self.save_checkpoint(val_acc, model)\n self.counter = 0\n\n def save_checkpoint(self, val_acc, model):\n '''Saves model when validation loss decrease.'''\n if self.verbose:\n print(\n f'Validation accuracy increased for {self.name} ({self.val_acc_max:.6f} --> {val_acc:.6f}). Saving model ...')\n\n save_dir = self.wandb.run.dir\n torch.save(model.state_dict(), save_dir + \"/\" + self.name + \".pt\")\n self.val_acc_max = val_acc\n\n\nclass Cutout(object):\n \"\"\"Randomly mask out one or more patches from an image.\n Args:\n n_holes (int): Number of patches to cut out of each image.\n length (int): The length (in pixels) of each square patch.\n \"\"\"\n\n def __init__(self, n_holes, length):\n self.n_holes = n_holes\n self.length = length\n\n def __call__(self, img):\n \"\"\"\n Args:\n img (Tensor): Tensor image of size (C, H, W).\n Returns:\n Tensor: Image with n_holes of dimension length x length cut out of it.\n \"\"\"\n h = img.size(1)\n w = img.size(2)\n\n mask = np.ones((h, w), np.float32)\n\n for n in range(self.n_holes):\n y = np.random.randint(h)\n x = np.random.randint(w)\n\n y1 = np.clip(y - self.length // 2, 0, h)\n y2 = np.clip(y + self.length // 2, 0, h)\n x1 = np.clip(x - self.length // 2, 0, w)\n x2 = np.clip(x + self.length // 2, 0, w)\n\n mask[y1: y2, x1: x2] = 0.\n\n mask = torch.from_numpy(mask)\n mask = mask.expand_as(img)\n img = img * mask\n\n return img\n"
] |
[
[
"torch.zeros",
"torch.cuda.manual_seed_all",
"torch.eq",
"numpy.random.seed",
"torch.FloatTensor",
"numpy.ones",
"torch.no_grad",
"numpy.mean",
"torch.from_numpy",
"torch.manual_seed",
"torch.cuda.is_available",
"numpy.random.randint",
"numpy.clip",
"sklearn.metrics.f1_score",
"torch.argmax"
]
] |
crmauceri/dataset_loaders
|
[
"542401b1a9a1ca98a15b4e529a3e78f9d0f91f52"
] |
[
"dataloaders/plots.py"
] |
[
"from PIL import Image, ImageDraw, ImageFont\nimport torch, random\nfrom dataloaders.utils import xywh2xyxy\n\n## Modified from https://github.com/ultralytics/yolov5/utils/plots.py under GNU License\ndef plot_bboxes(images, targets, fname='images.jpg', names=None, max_size=640, max_subplots=16, colors=None):\n # Plot image grid with labels\n if isinstance(images, torch.Tensor):\n images = images.cpu().float().numpy()\n if isinstance(targets, torch.Tensor):\n targets = targets.cpu().numpy()\n\n # un-normalise\n if np.max(images[0]) <= 1:\n images *= 255\n\n tl = 3 # line thickness\n tf = max(tl - 1, 1) # font thickness\n bs, _, h, w = images.shape # batch size, _, height, width\n bs = min(bs, max_subplots) # limit plot images\n ns = np.ceil(bs ** 0.5) # number of subplots (square)\n\n # Check if we should resize\n scale_factor = max_size / max(h, w)\n if scale_factor < 1:\n h = math.ceil(scale_factor * h)\n w = math.ceil(scale_factor * w)\n\n mosaic = np.full((int(ns * h), int(ns * w), 3), 255, dtype=np.float32) # init\n for i, sample in enumerate(zip(images, targets)):\n img, image_targets = sample\n if i == max_subplots: # if last batch has fewer images than we expect\n break\n\n block_x = int(w * (i // ns))\n block_y = int(h * (i % ns))\n\n img = Image.fromarray(img.transpose(1, 2, 0)[:, :, :3].astype(np.uint8))\n if scale_factor < 1:\n img = img.resize((w, h))\n\n if image_targets.shape[0] > 0:\n boxes = xywh2xyxy(image_targets[:, 1:5]).T\n classes = image_targets[:, 0].astype('int')\n labels = image_targets.shape[1] == 5 # labels if no conf column\n conf = None if labels else image_targets[:, 6] # check for confidence presence (label vs pred)\n\n if boxes.shape[1]:\n if boxes.max() <= 1.01: # if normalized with tolerance 0.01\n boxes[[0, 2]] *= w # scale to pixels\n boxes[[1, 3]] *= h\n elif scale_factor < 1: # absolute coords need scale if image scales\n boxes *= scale_factor\n boxes[[0, 2]] += block_x\n boxes[[1, 3]] += block_y\n for j, box in enumerate(boxes.T):\n cls = int(classes[j])\n if colors is not None:\n color = colors[cls % len(colors)]\n else:\n color = None\n cls = names[cls] if names else cls\n if labels or conf[j] > 0.25: # 0.25 conf thresh\n label = '%s' % cls if labels else '%s %.1f' % (cls, conf[j])\n plot_one_box(box, img, label=label, color=color, line_thickness=tl)\n\n # Image border\n draw = ImageDraw.Draw(img)\n draw.rectangle([(0, 0), img.size], outline=(255, 255, 255), width=3)\n mosaic[block_y:block_y + h, block_x:block_x + w, :] = np.array(img)\n\n if fname:\n r = min(1280. / max(h, w) / ns, 1.0) # ratio to limit image size\n mosaic_img = Image.fromarray(mosaic[:, :, :3].astype(np.uint8))\n mosaic_img.resize((int(ns * w * r), int(ns * h * r)))\n mosaic_img.save(fname) # PIL save\n return mosaic\n\ndef plot_one_box(x, img, color=None, label=None, line_thickness=None):\n # Plots one bounding box on image img\n tl = line_thickness or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1 # line/font thickness\n color = color or [random.randint(0, 255) for _ in range(3)]\n c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))\n draw = ImageDraw.Draw(img)\n draw.rectangle([c1, c2], outline=color, width=tl) # [(x0, y0), (x1, y1)]\n if label:\n tf = max(tl - 1, 1) # font thickness\n fnt = ImageFont.truetype(\"/Library/Fonts/Arial.ttf\") #, tl / 3)\n t_size = fnt.getsize(label)\n c2 = c1[0] + t_size[0]*1.5, c1[1] - t_size[1] - 3\n draw.rectangle([c1, c2], fill=color) # filled\n draw.text((c1[0], c1[1] - t_size[1]), label, fnt=fnt)\n\nif __name__ == '__main__':\n from dataloaders import make_dataset\n from torch.utils.data import DataLoader\n import matplotlib.pyplot as plt\n import numpy as np\n import math\n from dataloaders.config.defaults import get_cfg_defaults\n\n cfg = get_cfg_defaults()\n cfg.merge_from_file('configs/sunrgbd.yaml')\n cfg.merge_from_list(['DATASET.ANNOTATION_TYPE', 'bbox',\n 'DATASET.NO_TRANSFORMS', True,\n 'TRAIN.BATCH_SIZE', 1])\n\n # Same as main method of dataloaders.datasets.coco\n val = make_dataset(cfg, split='val')\n dataloader = DataLoader(val, batch_size=16, shuffle=False, num_workers=0)\n names = [x.replace('_', ' ') for x in val.loader.class_names]\n\n for ii, sample in enumerate(dataloader):\n mosaic = plot_bboxes(sample[\"image\"], sample[\"label\"], names=names)\n plt.figure()\n plt.imshow(mosaic.astype(np.uint8))\n plt.show()\n break"
] |
[
[
"numpy.max",
"numpy.array",
"numpy.ceil",
"matplotlib.pyplot.figure",
"torch.utils.data.DataLoader",
"matplotlib.pyplot.show"
]
] |
Loptt/pong-autoencoder
|
[
"c5123bb2466f644f7513d807044e11a4a17aae22"
] |
[
"latent_tests/generate_latent_dataset.py"
] |
[
"import os\r\nos.add_dll_directory(\r\n \"C:\\\\Program Files\\\\NVIDIA GPU Computing Toolkit\\\\CUDA\\\\v11.4\\\\bin\")\r\n\r\nimport tensorflow as tf\r\nfrom keras.preprocessing.image import load_img\r\nfrom keras.preprocessing.image import img_to_array\r\nfrom keras.models import load_model\r\nimport matplotlib.pyplot as plt\r\nimport pickle\r\n\r\ndef load_images(path):\r\n files = os.listdir(path)\r\n images = []\r\n\r\n for f in files:\r\n print(\"Loading \" + path + f)\r\n img = load_img(path + f, color_mode='grayscale')\r\n img_arr = img_to_array(img)\r\n images.append(img_arr)\r\n \r\n return tf.constant(images)\r\n\r\ndef find_balls(data):\r\n # Assuming data is tensor shape (batch_size, height, width , 1)\r\n y = tf.math.reduce_max(tf.math.argmax(data, axis=1), axis=1)\r\n x = tf.math.reduce_max(tf.math.argmax(data, axis=2), axis=1)\r\n return tf.concat([x, y], axis=1)\r\n\r\ndef find_paddles(data):\r\n # Assuming data is tensor shape (batch_size, height, width , 1)\r\n left_paddle = data[:, :, :10]\r\n right_paddle = data[:, :, 10:]\r\n\r\n left_y = tf.math.reduce_max(tf.math.argmax(left_paddle, axis=1), axis=1)\r\n left_x = tf.math.reduce_max(tf.math.argmax(left_paddle, axis=2), axis=1)\r\n\r\n right_y = tf.math.reduce_max(tf.math.argmax(right_paddle, axis=1), axis=1)\r\n right_x = tf.math.reduce_max(tf.math.argmax(right_paddle, axis=2), axis=1)\r\n\r\n return tf.concat([left_x, left_y, right_x, right_y], axis=1)\r\n\r\nif __name__ == '__main__':\r\n imgs_paddle = load_images(\"./images_ballless/\")\r\n imgs_ball = load_images(\"./images_paddleless_big/\")\r\n\r\n model_paddle = load_model(\"./prod_models/vae_ballless\")\r\n model_ball = load_model(\"./prod_models/vae_big_paddleless\")\r\n\r\n latents_paddle = tf.constant(model_paddle.encoder.predict(imgs_paddle)[2])\r\n latents_ball = tf.constant(model_ball.encoder.predict(imgs_ball)[2])\r\n\r\n paddles_loc = find_paddles(imgs_paddle)\r\n balls_loc = find_balls(imgs_ball)\r\n\r\n pickle.dump((latents_paddle, paddles_loc), open('./latent_tests/paddle_latent_ds.p', 'wb'))\r\n pickle.dump((latents_ball, balls_loc), open('./latent_tests/balls_latent_ds.p', 'wb'))\r\n\r\n \r\n"
] |
[
[
"tensorflow.constant",
"tensorflow.math.argmax",
"tensorflow.concat"
]
] |
JosephineRabbit/TAL_attention
|
[
"d04ef6ecf4b67a41e4c672f39e811327faf31951"
] |
[
"gtad_GA_NL_4_train.py"
] |
[
"import os\nimport torch\nimport torch.nn.parallel\nimport torch.optim as optim\nfrom torch import autograd\nimport numpy as np\n\nfrom gtad_lib import opts\nfrom gtad_lib.model_GA_NL_4 import GTAD\nfrom gtad_lib.dataset import VideoDataSet\nfrom gtad_lib.loss_function import get_mask, gtad_loss_func # subgraph_loss_func, node_loss_func\n\n################## fix everything ##################\nimport random\n\nseed = 0\nrandom.seed(seed)\nnp.random.seed(seed)\ntorch.manual_seed(seed)\ntorch.cuda.manual_seed(seed)\ntorch.cuda.manual_seed_all(seed)\ntorch.backends.cudnn.deterministic = True\ntorch.backends.cudnn.benchmark = False\n\n\n#######################################################\ndef load_checkpoint(model, checkpoint):\n\n print(\"loading checkpoint...\")\n model_dict = model.state_dict()\n modelCheckpoint = torch.load(checkpoint)\n pretrained_dict = modelCheckpoint['state_dict']\n # 过滤操作\n new_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict.keys()}\n model_dict.update(new_dict)\n # 打印出来，更新了多少的参数\n print('Total : {}, update: {}'.format(len(pretrained_dict), len(new_dict)))\n model.load_state_dict(model_dict)\n print(\"loaded finished!\")\n\n return model\n\n# keep track of statistics\nclass AverageMeter(object):\n def __init__(self):\n self.sum = 0\n self.count = 0\n\n def update(self, val, n=1):\n self.sum += val\n self.count += n\n\n def avg(self):\n return self.sum / self.count\n\n\ndef get_mem_usage():\n GB = 1024.0 ** 3\n output = [\"device_%d = %.03fGB\" % (device, torch.cuda.max_memory_allocated(torch.device('cuda:%d' % device)) / GB)\n for device in range(opt['n_gpu'])]\n return ' '.join(output)[:-1]\n\n\n# train\ndef train(data_loader, model, optimizer, epoch, bm_mask):\n model.train()\n total_am, subgraph_am, node_am = AverageMeter(), AverageMeter(), AverageMeter()\n for n_iter, (input_data, label_confidence, label_start, label_end) in enumerate(data_loader):\n # forward pass\n confidence_map, start, end = model(input_data.cuda())\n # loss\n loss = gtad_loss_func(confidence_map, start, end, label_confidence, label_start, label_end, bm_mask.cuda())\n\n # update step\n optimizer.zero_grad()\n loss[0].backward()\n # torch.nn.utils.clip_grad_norm_(model.parameters(), 1)\n optimizer.step()\n\n # update losses\n total_am.update(loss[0].detach())\n subgraph_am.update(loss[1].detach())\n node_am.update(loss[2].detach())\n\n print(\"[Epoch {0:03d}]\\tLoss {1:.2f} = {2:.2f} + {3:.2f} (train)\".format(\n epoch, total_am.avg(), subgraph_am.avg(), node_am.avg()))\n\n\ndef test(data_loader, model, epoch, bm_mask, best_loss):\n model.eval()\n total_am, subgraph_am, node_am = AverageMeter(), AverageMeter(), AverageMeter()\n with torch.no_grad():\n for n_iter, (input_data, label_confidence, label_start, label_end) in enumerate(data_loader):\n # forward pass\n confidence_map, start, end = model(input_data.cuda())\n # loss\n # gt_iou_map = label_confidence.cuda() * bm_mask\n loss = gtad_loss_func(confidence_map, start, end, label_confidence, label_start, label_end, bm_mask.cuda())\n\n # update losses\n total_am.update(loss[0].detach())\n subgraph_am.update(loss[1].detach())\n node_am.update(loss[2].detach())\n\n print(\"[Epoch {0:03d}]\\tLoss {1:.2f} = {2:.2f} + {3:.2f} (validation)\".format(\n epoch, total_am.avg(), subgraph_am.avg(), node_am.avg()))\n\n state = {'epoch': epoch + 1,\n 'state_dict': model.state_dict()}\n torch.save(state, opt[\"output\"] + \"/GTAD_checkpoint_\"+str(epoch)+\".pth.tar\")\n if total_am.avg() < best_loss:\n\n best_loss = total_am.avg()\n torch.save(state, opt[\"output\"] + \"/GTAD_best.pth.tar\")\n\n\n return best_loss\n\n\nif __name__ == '__main__':\n opt = opts.parse_opt()\n opt = vars(opt)\n opt['output'] = './GA_NL_4_output'\n if not os.path.exists(opt[\"output\"]):\n os.makedirs(opt[\"output\"])\n\n # model = GTAD(opt)\n # a = torch.randn(1, 400, 100)\n # b, c = model(a)\n # print(b.shape, c.shape)\n # print(b)\n # print(c)\n\n centers = torch.load('./centers/512_200_centers.rar')\n centers = centers[:, :400]\n device = torch.device(\"cuda:0,1\")\n centers = centers.to(device)\n\n model = GTAD(opt, centers)\n\n policies = model.get_optim_policies()\n\n model = torch.nn.DataParallel(model, device_ids=list(range(opt['n_gpu']))).cuda()\n #path = './output/GTAD_best.pth.tar'\n #model = load_checkpoint(model,path)\n print('use {} gpus to train!'.format(opt['n_gpu']))\n\n optimizer = optim.Adam(policies, lr=opt[\"training_lr\"],\n weight_decay=opt[\"weight_decay\"])\n train_loader = torch.utils.data.DataLoader(VideoDataSet(opt, subset=\"train\"),\n batch_size=opt[\"batch_size\"], shuffle=True,\n num_workers=8, pin_memory=True)\n\n test_loader = torch.utils.data.DataLoader(VideoDataSet(opt, subset=\"validation\"),\n batch_size=opt[\"batch_size\"], shuffle=False,\n num_workers=8, pin_memory=True)\n\n scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=opt[\"step_size\"], gamma=opt[\"step_gamma\"])\n mask = get_mask(opt[\"temporal_scale\"])\n best_loss = 1e10\n\n for epoch in range(opt[\"train_epochs\"]):\n with autograd.detect_anomaly():\n train(train_loader, model, optimizer, epoch, mask)\n best_loss = test(test_loader, model, epoch, mask, best_loss)\n scheduler.step()\n\n\n\n"
] |
[
[
"torch.device",
"torch.cuda.manual_seed",
"torch.cuda.manual_seed_all",
"torch.optim.lr_scheduler.StepLR",
"numpy.random.seed",
"torch.no_grad",
"torch.optim.Adam",
"torch.save",
"torch.manual_seed",
"torch.load",
"torch.autograd.detect_anomaly"
]
] |
L-Zhe/SDISS
|
[
"0ee3f8614f4d92a3c916d04457784dbdffac8a06"
] |
[
"generate.py"
] |
[
"import torch\nimport Constants\nfrom Preprocess import translate2word, restore2Ori\nfrom Parameter import device, maxLen\n\ndef generator(model, testData, SrcOriPath, index2word, DictPath, search_method, beam_size):\n model.eval()\n translate = lambda outputs: [translate2word(seq, index2word) for seq in outputs]\n outputs = []\n attn_weight = []\n with torch.no_grad():\n for data in testData:\n if len(data) == 3:\n source, graph, rgraph = data\n else:\n source, graph, rgraph, _, _ = data\n source = source.to(device)\n lentok = torch.LongTensor(source.size(0), 1).fill_(Constants.MIDDLE).to(device)\n source = torch.cat((lentok, source), dim=-1)\n graph = graph.to(device)\n rgraph = rgraph.to(device)\n sentence, attn = model.predict(source, graph, rgraph, maxLen,\n Constants.PAD, Constants.BOS, Constants.EOS,\n search_method=search_method, beam_size=beam_size)\n outputs.extend(translate(sentence))\n attn_weight.extend(attn)\n outputs = restore2Ori(outputs, DictPath)\n return replaceUNK(SrcOriPath, outputs, attn_weight)\n\n\ndef replaceUNK(srcPath, sentence, attn):\n with open(srcPath, 'r') as f:\n source = [[word.lower() for word in line.split()] for line in f.readlines()]\n for i in range(len(sentence)):\n for j in range(len(sentence[i])):\n if sentence[i][j] == Constants.UNK_WORD:\n sentence[i][j] = source[i][attn[i][j] - 1]\n return sentence\n\n\nif __name__ == '__main__':\n pass"
] |
[
[
"torch.no_grad",
"torch.cat"
]
] |
tpopordanoska/confidence-intervals
|
[
"6b9325093fdfd9dd903a56d6832e472427a4a24f"
] |
[
"cieg/experiments/methods/pmatrix.py"
] |
[
"import os\n\nimport numpy as np\nimport torch\n\n\ndef pmatrix_bounds(eigvals_lower, eigvals_upper, eigvects_lower, eigvects_upper, sigma, eig):\n inv_eigvals_lower, inv_eigvals_upper = get_inverse_eigenvalue_bounds(eigvals_lower, eigvals_upper)\n p = eig.eigenvalues.size()[0]\n lower_bound, upper_bound = get_pmatrix_bounds(sigma,\n eigvects_lower,\n eigvects_upper,\n inv_eigvals_upper,\n inv_eigvals_lower,\n p)\n\n non_zero_precision = (lower_bound > 0) + (upper_bound < 0) > 0\n\n return lower_bound, upper_bound, non_zero_precision\n\n\ndef get_inverse_eigenvalue_bounds(lambdas_lower, lambdas_upper):\n inv_lambdas_lower = 1.0 / lambdas_upper\n inv_lambdas_upper = 1.0 / lambdas_lower\n\n return inv_lambdas_lower, inv_lambdas_upper\n\n\ndef get_pmatrix_bounds(sigma, v_lower, v_upper, inv_lambdas_upper, inv_lambdas_lower, p):\n # initialize to zero\n lower_bound = torch.zeros_like(sigma)\n upper_bound = torch.zeros_like(sigma)\n # Now reconstruct the bounds on the precision matrix using interval arithmetic over the matrix multiplication of\n # V*Sig^{-1}*V^T. Doing it naively for now, vectorize it later\n for i in range(p):\n for j in range(p):\n for k in range(p):\n updated_this_round = False\n # CHECK IF ANY OF THE LOWER OR UPPER BOUNDS ARE ZERO! HAVEN'T IMPLEMENTED THESE CASES\n if (v_lower[i, k] == 0) + (v_upper[i, k] == 0) + (v_lower[j, k] == 0) + (v_upper[j, k] == 0):\n print(\"oh no, some value is zero\")\n print(v_lower[i, k])\n print(v_upper[i, k])\n print(v_lower[j, k])\n print(v_upper[j, k])\n continue\n # assert False # die here, fix code for these cases rather than return false result\n # case 1a: i lower is positive; j lower is positive\n if (v_lower[i, k] > 0) * (v_lower[j, k] > 0):\n lower_bound[i, j] += v_lower[i, k] * inv_lambdas_lower[k] * v_lower[j, k]\n upper_bound[i, j] += v_upper[i, k] * inv_lambdas_upper[k] * v_upper[j, k]\n updated_this_round = True\n # case 2a: i lower is negative, upper is positive; j lower is positive\n if (v_lower[i, k] < 0) * (v_upper[i, k] > 0) * (v_lower[j, k] > 0):\n lower_bound[i, j] += v_lower[i, k] * inv_lambdas_upper[k] * v_upper[j, k]\n upper_bound[i, j] += v_upper[i, k] * inv_lambdas_upper[k] * v_upper[j, k]\n updated_this_round = True\n # case 3a: i upper is negative; j lower is positive\n if (v_upper[i, k] < 0) * (v_lower[j, k] > 0):\n lower_bound[i, j] += v_lower[i, k] * inv_lambdas_upper[k] * v_upper[j, k]\n upper_bound[i, j] += v_upper[i, k] * inv_lambdas_lower[k] * v_lower[j, k]\n updated_this_round = True\n\n # case 1b: i lower and upper are positive; j lower is negative, upper is positive\n if (v_lower[i, k] > 0) * (v_lower[j, k] < 0) * (v_upper[j, k] > 0):\n lower_bound[i, j] += v_upper[i, k] * inv_lambdas_upper[k] * v_lower[j, k]\n upper_bound[i, j] += v_upper[i, k] * inv_lambdas_upper[k] * v_upper[j, k]\n updated_this_round = True\n # case 2b: i lower is negative, upper is positive; j lower is negative, upper is positive\n # this is the complicated one where there are a couple possibilities\n if (v_lower[i, k] < 0) * (v_upper[i, k] > 0) * (v_lower[j, k] < 0) * (v_upper[j, k] > 0):\n # Lower bound will be negative (unless i==j), and there are two possibilities for this\n tmp = v_lower[i, k] * inv_lambdas_upper[k] * v_upper[j, k]\n if tmp > v_upper[i, k] * inv_lambdas_upper[k] * v_lower[j, k]:\n tmp = v_upper[i, k] * inv_lambdas_upper[k] * v_lower[j, k]\n if i == j:\n # in this case, the minimum is actually zero as we are on the diagonal\n if tmp < 0: # this condition should always hold, but just being explicit\n tmp = 0\n lower_bound[i, j] += tmp\n # Upper bound will be positive, and there are two possibilities for this\n tmp = v_lower[i, k] * inv_lambdas_upper[k] * v_lower[j, k]\n if tmp < v_upper[i, k] * inv_lambdas_upper[k] * v_upper[j, k]:\n tmp = v_upper[i, k] * inv_lambdas_upper[k] * v_upper[j, k]\n upper_bound[i, j] += tmp\n updated_this_round = True\n # case 3b: i lower and upper are negative; j lower is negative, upper is positive\n if (v_upper[i, k] < 0) * (v_lower[j, k]<0) * (v_upper[j, k] > 0):\n lower_bound[i, j] += v_lower[i, k] * inv_lambdas_upper[k] * v_upper[j, k]\n upper_bound[i, j] += v_lower[i, k] * inv_lambdas_upper[k] * v_lower[j, k]\n updated_this_round = True\n\n # case 1c: i lower and upper are positive; j lower and upper are negative\n if (v_lower[i, k]>0) * (v_upper[j, k]<0):\n lower_bound[i, j] += v_upper[i, k] * inv_lambdas_upper[k] * v_lower[j, k]\n upper_bound[i, j] += v_lower[i, k] * inv_lambdas_lower[k] * v_upper[j, k]\n updated_this_round = True\n # case 2c: i lower is negative, upper is positive; j lower and upper are negative\n if (v_lower[i, k] < 0) * (v_upper[i, k] > 0) * (v_upper[j, k] < 0):\n lower_bound[i, j] += v_upper[i, k] * inv_lambdas_upper[k] * v_lower[j, k]\n upper_bound[i, j] += v_lower[i, k] * inv_lambdas_upper[k] * v_lower[j, k]\n updated_this_round = True\n # case 3c: i lower and upper are negative; j lower and upper are negative\n if (v_upper[i, k] < 0) * (v_upper[j, k] < 0):\n lower_bound[i, j] += v_upper[i, k] * inv_lambdas_lower[k] * v_upper[j, k]\n upper_bound[i, j] += v_lower[i, k] * inv_lambdas_upper[k] * v_lower[j, k]\n updated_this_round = True\n\n if not updated_this_round:\n print(i)\n print(j)\n print(k)\n print(v_lower[i, k])\n print(v_upper[i, k])\n print(v_lower[j, k])\n print(v_upper[j, k])\n print(inv_lambdas_lower[k])\n print(inv_lambdas_upper[k])\n assert False # should have hit at least one of the cases!\n\n return lower_bound, upper_bound\n\n\ndef print_pmatrix_bounds(lower, upper, prec_emp):\n print(\"Verifying bounds\")\n print(f\"Prec. matrix lower: {lower}\")\n print(f\"Prec. matrix: {prec_emp}\")\n print(f\"Prec. matrix upper: {upper}\")\n\n\ndef check_pmatrix_bounds(lower, upper, prec_emp):\n print(\"Verifying bounds\")\n assert torch.all(lower.lt(prec_emp))\n assert torch.all(upper.gt(prec_emp))\n\n # upper bounds and lower bounds should bound the empirical precision matrix\n assert torch.min(upper - prec_emp) >= 0\n assert torch.min(prec_emp - lower) >= 0\n\n\ndef save_pmatrix_bounds(lower, upper, prec_emp, path, method):\n np.save(os.path.join(path, f\"pm_lower_{method}.npy\"), lower)\n np.save(os.path.join(path, f\"pm_upper_{method}.npy\"), upper)\n np.save(os.path.join(path, f\"pm_emp_{method}.npy\"), prec_emp)\n\n\ndef save_eig_bounds(eigvals_lower, eigvals_upper, eigvects_lower, eigvects_upper, eig, path, method):\n np.save(os.path.join(path, f\"eigvals_lower_{method}.npy\"), eigvals_lower)\n np.save(os.path.join(path, f\"eigvals_upper_{method}.npy\"), eigvals_upper)\n np.save(os.path.join(path, f\"eigvals_emp_{method}.npy\"), eig.eigenvalues)\n\n np.save(os.path.join(path, f\"eigvects_lower_{method}.npy\"), eigvects_lower)\n np.save(os.path.join(path, f\"eigvects_upper_{method}.npy\"), eigvects_upper)\n np.save(os.path.join(path, f\"eigvects_emp_{method}.npy\"), eig.eigenvectors)\n\n\ndef load_pmatrix_bounds(path, method):\n lower = np.load(os.path.join(path, f\"pm_lower_{method}.npy\"))\n upper = np.load(os.path.join(path, f\"pm_upper_{method}.npy\"))\n emp = np.load(os.path.join(path, f\"pm_emp_{method}.npy\"))\n\n return lower, upper, emp\n\n\ndef load_eig_bounds(path, method):\n eigvals_lower = np.load(os.path.join(path, f\"eigvals_lower_{method}.npy\"))\n eigvals_upper = np.load(os.path.join(path, f\"eigvals_upper_{method}.npy\"))\n eigvals_emp = np.load(os.path.join(path, f\"eigvals_emp_{method}.npy\"))\n\n eigvects_lower = np.load(os.path.join(path, f\"eigvects_lower_{method}.npy\"))\n eigvects_upper = np.load(os.path.join(path, f\"eigvects_upper_{method}.npy\"))\n eigvects_emp = np.load(os.path.join(path, f\"eigvects_emp_{method}.npy\"))\n\n return eigvals_lower, eigvals_upper, eigvals_emp, eigvects_lower, eigvects_upper, eigvects_emp\n"
] |
[
[
"torch.zeros_like",
"torch.min"
]
] |
tranduytrung/rgbd-classification
|
[
"156d829200c4592867af5ade85e8642afbe8580e"
] |
[
"train.py"
] |
[
"import os, json, glob, copy, argparse, shutil\nimport torch\nimport torchvision\nimport numpy as np\nimport PIL.Image\nfrom datetime import datetime\nfrom config import get_train_config\nfrom models import DepthNet, RGBNet, RGBDNet\nimport augmentation\nimport loaders\nfrom tensorboardX import SummaryWriter\nfrom utils import load_last\n\n\ndef save_acc_hist(acc_hist, ckpt_root):\n np.save(f'{ckpt_root}/acc_hist.npy', acc_hist)\n\n\ndef train_model(model, data_loader, criterion, optimizer, scheduler, cfg, resume=True):\n best_acc = 0.0\n best_epoch = 0\n max_epoch = cfg['max_epoch']\n ckpt_root = cfg['ckpt_root']\n batch_size = cfg['batch_size']\n\n summary = SummaryWriter(ckpt_root)\n\n if resume:\n model, last_epoch, val_acc_hist = load_last(model, ckpt_root)\n if len(val_acc_hist) > 0:\n arg_best_acc = np.argmax(val_acc_hist)\n best_epoch = arg_best_acc + 1\n best_acc = val_acc_hist[arg_best_acc]\n for _ in range(last_epoch):\n scheduler.step()\n\n start_epoch = last_epoch + 1\n\n for epoch in range(start_epoch, max_epoch + 1):\n\n print('-' * 60)\n print('Epoch: {} / {}'.format(epoch, max_epoch))\n print('-' * 60)\n\n for phrase in ['train', 'val']:\n\n if phrase == 'train':\n scheduler.step()\n model.train()\n else:\n model.eval()\n\n running_loss = 0.0\n running_corrects = 0\n\n dataset_size = len(data_loader[phrase].dataset)\n total_steps = int(dataset_size / batch_size)\n\n for i, (images, targets) in enumerate(data_loader[phrase]):\n optimizer.zero_grad()\n\n if torch.cuda.is_available():\n images = images.cuda()\n targets = targets.cuda()\n\n with torch.set_grad_enabled(phrase == 'train'):\n outputs = model(images)\n _, preds = torch.max(outputs, 1)\n loss = criterion(outputs, targets)\n\n if phrase == 'train':\n loss.backward()\n optimizer.step()\n\n batch_loss = loss.item()\n batch_correct = torch.sum(preds == targets.data).item()\n batch_acc = batch_correct / batch_size\n running_loss += batch_loss * batch_size\n running_corrects += batch_correct\n\n print(\n f'{datetime.now()} {phrase} epoch={epoch}/{max_epoch} step={i}/{total_steps} loss={batch_loss:.4f} acc={batch_acc:.4f}')\n summary.add_scalar(\n f'{phrase}/batch/loss', batch_loss, global_step=(epoch - 1)*total_steps + i)\n\n epoch_loss = running_loss / dataset_size\n epoch_acc = running_corrects / dataset_size\n\n if phrase == 'train':\n print('{} {} Loss: {:.4f} Acc: {:.4f}'.format(\n datetime.now(), phrase, epoch_loss, epoch_acc))\n print('================================')\n\n if phrase == 'val':\n val_acc_hist.append(epoch_acc)\n save_acc_hist(val_acc_hist, ckpt_root)\n if epoch_acc > best_acc:\n best_acc = epoch_acc\n best_epoch = epoch\n\n filename = os.path.join(ckpt_root, f'{epoch:04d}.pkl')\n torch.save(copy.deepcopy(model.state_dict()), filename)\n\n print(\n f'{phrase} epoch={epoch} loss={epoch_loss:.4f} acc={epoch_acc:.4f}')\n\n summary.add_scalar(f'{phrase}/epoch/accuracy',\n epoch_acc, global_step=epoch*total_steps)\n summary.add_scalar(f'{phrase}/epoch/loss',\n epoch_loss, global_step=epoch*total_steps)\n\n summary.close()\n return best_epoch, best_acc\n\n\ndef train_depth(cfg):\n imagenet_transform_train = torchvision.transforms.Compose([\n augmentation.CropAndResize((224, 224), scale=(0.4, 1.0)),\n torchvision.transforms.ToTensor(),\n augmentation.DepthTranslate(minmax=(0, .8)),\n augmentation.GaussianNoise(std=0.005),\n augmentation.DepthUniformNoise(p=0.01, minmax=(0.15, 1.0)),\n augmentation.Clamp((0.15, 1.0)),\n torchvision.transforms.Normalize(mean=[0.575], std=[0.425])\n ])\n\n imagenet_transform_val = torchvision.transforms.Compose([\n augmentation.CenterCrop((224, 224)),\n torchvision.transforms.ToTensor(),\n augmentation.DepthTranslate(minmax=(0, .8)),\n augmentation.GaussianNoise(std=0.005),\n augmentation.DepthUniformNoise(p=0.01, minmax=(0.15, 1.0)),\n augmentation.Clamp((0.15, 1.0)),\n torchvision.transforms.Normalize(mean=[0.575], std=[0.425])\n ])\n\n datasets = {\n \"train\": torchvision.datasets.DatasetFolder(cfg['data_root']['train'], loaders.depth_from_exr, extensions=('depth.exr'), transform=imagenet_transform_train),\n \"val\": torchvision.datasets.DatasetFolder(cfg['data_root']['val'], loaders.depth_from_exr, extensions=('depth.exr'), transform=imagenet_transform_val),\n }\n\n num_workers = cfg['worker']\n data_loader = {\n \"train\": torch.utils.data.DataLoader(datasets['train'], batch_size=cfg['batch_size'],\n num_workers=num_workers, shuffle=True, pin_memory=True, drop_last=True),\n \"val\": torch.utils.data.DataLoader(datasets['val'], batch_size=cfg['batch_size'],\n num_workers=num_workers, shuffle=True, pin_memory=True, drop_last=True),\n }\n\n assert len(datasets['train'].classes) == len(datasets['val'].classes)\n # save classes name\n classes = datasets['train'].classes\n os.makedirs(cfg['ckpt_root'], exist_ok=True)\n with open(os.path.join(cfg['ckpt_root'], 'classes.json'), 'wt') as f:\n json.dump(classes, f)\n\n cfg_depth = cfg['depth']\n cfg_depth['num_classes'] = len(classes)\n model = DepthNet(cfg_depth)\n # enable cuda if available\n if torch.cuda.is_available():\n model = model.cuda()\n\n criterion = torch.nn.CrossEntropyLoss()\n # optimizer = torch.optim.SGD(model.parameters(), lr=cfg['lr'], momentum=cfg['momentum'], weight_decay=cfg['weight_decay'])\n optimizer = torch.optim.Adam(\n model.parameters(), lr=cfg['lr'], weight_decay=cfg['weight_decay'])\n # scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=cfg['milestones'], gamma=cfg['gamma'])\n scheduler = torch.optim.lr_scheduler.StepLR(\n optimizer, 10, gamma=cfg['gamma'])\n\n train_model(model, data_loader, criterion,\n optimizer, scheduler, cfg, resume=True)\n\n\ndef train_rgb(cfg):\n imagenet_transform_train = torchvision.transforms.Compose([\n augmentation.GaussianBlur(r=1),\n torchvision.transforms.RandomResizedCrop(224, scale=(0.25, 1.0)),\n torchvision.transforms.ToTensor(),\n augmentation.GaussianNoise(),\n augmentation.Clamp((0.0, 1.0)),\n torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n ])\n\n imagenet_transform_val = torchvision.transforms.Compose([\n augmentation.GaussianBlur(r=1),\n torchvision.transforms.CenterCrop(224),\n torchvision.transforms.ToTensor(),\n augmentation.GaussianNoise(),\n augmentation.Clamp((0.0, 1.0)),\n torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n ])\n\n datasets = {\n \"train\": torchvision.datasets.DatasetFolder(cfg['data_root']['train'], loaders.rgb_from_image, extensions=('rgb.png'), transform=imagenet_transform_train),\n \"val\": torchvision.datasets.DatasetFolder(cfg['data_root']['val'], loaders.rgb_from_image, extensions=('rgb.png'), transform=imagenet_transform_val),\n }\n\n num_workers = cfg['worker']\n data_loader = {\n \"train\": torch.utils.data.DataLoader(datasets['train'], batch_size=cfg['batch_size'],\n num_workers=num_workers, shuffle=True, pin_memory=True, drop_last=True),\n \"val\": torch.utils.data.DataLoader(datasets['val'], batch_size=cfg['batch_size'],\n num_workers=num_workers, shuffle=True, pin_memory=True, drop_last=True),\n }\n\n assert len(datasets['train'].classes) == len(datasets['val'].classes)\n # save classes name\n classes = datasets['train'].classes\n os.makedirs(cfg['ckpt_root'], exist_ok=True)\n with open(os.path.join(cfg['ckpt_root'], 'classes.json'), 'wt') as f:\n json.dump(classes, f)\n\n cfg_rgb = cfg['rgb']\n cfg_rgb['num_classes'] = len(classes)\n model = RGBNet(cfg_rgb)\n # enable cuda if available\n if torch.cuda.is_available():\n model = model.cuda()\n\n criterion = torch.nn.CrossEntropyLoss()\n # optimizer = torch.optim.SGD(model.parameters(), lr=cfg['lr'], momentum=cfg['momentum'], weight_decay=cfg['weight_decay'])\n optimizer = torch.optim.Adam(\n model.parameters(), lr=cfg['lr'], weight_decay=cfg['weight_decay'])\n # scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=cfg['milestones'], gamma=cfg['gamma'])\n scheduler = torch.optim.lr_scheduler.StepLR(\n optimizer, 10, gamma=cfg['gamma'])\n\n train_model(model, data_loader, criterion,\n optimizer, scheduler, cfg, resume=True)\n\ndef train_rgbd(cfg):\n datasets = {\n \"train\": loaders.RGBDDataset(cfg['data_root']['train'], loader=loaders.RGBDLoader(mode='train')),\n \"val\": loaders.RGBDDataset(cfg['data_root']['val'], loader=loaders.RGBDLoader(mode='val')),\n }\n\n num_workers = cfg['worker']\n data_loader = {\n \"train\": torch.utils.data.DataLoader(datasets['train'], batch_size=cfg['batch_size'],\n num_workers=num_workers, shuffle=True, pin_memory=True, drop_last=True),\n \"val\": torch.utils.data.DataLoader(datasets['val'], batch_size=cfg['batch_size'],\n num_workers=num_workers, shuffle=True, pin_memory=True, drop_last=True),\n }\n\n assert len(datasets['train'].classes) == len(datasets['val'].classes)\n # save classes name\n classes = datasets['train'].classes\n os.makedirs(cfg['ckpt_root'], exist_ok=True)\n with open(os.path.join(cfg['ckpt_root'], 'classes.json'), 'wt') as f:\n json.dump(classes, f)\n\n cfg_rgbd = cfg['rgbd']\n cfg_rgbd['num_classes'] = len(classes)\n model = RGBDNet(cfg_rgbd)\n # enable cuda if available\n if torch.cuda.is_available():\n model = model.cuda()\n\n criterion = torch.nn.CrossEntropyLoss()\n # optimizer = torch.optim.SGD(model.parameters(), lr=cfg['lr'], momentum=cfg['momentum'], weight_decay=cfg['weight_decay'])\n optimizer = torch.optim.Adam(\n model.parameters(), lr=cfg['lr'], weight_decay=cfg['weight_decay'])\n # scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=cfg['milestones'], gamma=cfg['gamma'])\n scheduler = torch.optim.lr_scheduler.StepLR(\n optimizer, 10, gamma=cfg['gamma'])\n\n train_model(model, data_loader, criterion,\n optimizer, scheduler, cfg, resume=True)\n\ndef parse_args():\n parser = argparse.ArgumentParser(description='Process some integers.')\n parser.add_argument('model', type=str)\n parser.add_argument('path', type=str)\n\n args = parser.parse_args()\n return {\n 'model': args.model,\n 'ckpt_root': args.path\n }\n\n\nif __name__ == \"__main__\":\n arg_cfg = parse_args()\n cfg = get_train_config()\n cfg.update(arg_cfg)\n model = cfg['model']\n if model == 'rgb':\n train_rgb(cfg)\n elif model == 'rgbd':\n train_rgbd(cfg)\n elif model == 'depth':\n train_depth(cfg)\n else:\n print(f'Error: unknown model {model}')\n"
] |
[
[
"torch.optim.lr_scheduler.StepLR",
"torch.max",
"torch.set_grad_enabled",
"numpy.save",
"torch.cuda.is_available",
"numpy.argmax",
"torch.utils.data.DataLoader",
"torch.nn.CrossEntropyLoss",
"torch.sum"
]
] |
UpStride/tutorial
|
[
"cbb8f78c4f70855031ca340b6a18befeded3e7d6"
] |
[
"quaternion-transformers/train_and_eval.py"
] |
[
"import logging\nimport sys\nimport os\nimport time\nimport datetime\nimport numpy as np\nimport tensorflow as tf\n\nfrom tabulate import tabulate\n\nfrom data_loading.dataset import dataset_factory\nfrom networks.optimization import OptimizationManager, \\\n loss_function, accuracy_function\nfrom networks.network import get_network\nfrom arguments.parser import PARSER\n\n# suppress warnings\nlogging.getLogger('tensorflow').setLevel(logging.ERROR)\n\nargs = PARSER.parse_args()\n\n# Dataset\ndataset = dataset_factory[args.task]()\nvocab_size = dataset.get_vocab_size()\ntrain_batches, test_batches = dataset.get_batched_data(args.batch_size)\n\n# Network\ntransformer = get_network(args, vocab_size)\n\n# Checkpoint management\nexp_name = args.exp_name\ncheckpoint_path = f\"./checkpoints/{dataset.get_dataset_name()}/{exp_name}\"\nif not os.path.exists(checkpoint_path):\n os.makedirs(checkpoint_path)\nckpt = tf.train.Checkpoint(transformer=transformer)\nckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5)\n\n# if a checkpoint exists, restore the latest checkpoint.\nif ckpt_manager.latest_checkpoint and args.from_pretrained:\n ckpt.restore(ckpt_manager.latest_checkpoint)\n print ('Latest checkpoint restored!!')\n\n# Tensorboard management\ntrain_loss = tf.keras.metrics.Mean(name='train_loss')\ntrain_accuracy = tf.keras.metrics.Mean(name='train_accuracy')\ntest_loss = tf.keras.metrics.Mean(name='test_loss')\ntest_accuracy = tf.keras.metrics.Mean(name='test_accuracy')\n\ncurrent_time = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\ntrain_log_dir = 'logs/' + exp_name + '/' + current_time + '/train'\ntest_log_dir = 'logs/' + exp_name + '/' + current_time + '/test'\ntrain_summary_writer = tf.summary.create_file_writer(train_log_dir)\ntest_summary_writer = tf.summary.create_file_writer(test_log_dir)\n\n# Optimization management\nopt_manager = OptimizationManager(args.task, transformer, args.d_model,\n train_loss, train_accuracy,\n test_loss, test_accuracy)\ntrain_step = opt_manager.get_train_step()\ntest_step = opt_manager.get_test_step()\n\nfor epoch in range(args.epochs):\n start = time.time()\n\n train_loss.reset_states()\n train_accuracy.reset_states()\n test_loss.reset_states()\n test_accuracy.reset_states()\n\n for (batch, (inp, tar)) in enumerate(train_batches):\n train_step(inp, tar)\n\n if epoch == 0 and batch == 0:\n weights = transformer.trainable_weights\n tab_list = [[v.name, v.get_shape(), np.prod(v.get_shape())] for v in weights]\n n_params = np.sum([tl[2] for tl in tab_list])\n n_params_no_embed = np.sum([tl[2]\n for tl in tab_list[:-2]\n if ('embedding' not in tl[0])])\n print(tabulate(tab_list, headers=['Name', 'Shape', 'Params']))\n print(f\"Number of trainable parameters: {n_params}\")\n print(\"Number of trainable parameters w/o the embedding layers\" +\n f\" and w/o the final dense layer: {n_params_no_embed}\")\n del weights\n\n if batch % 50 == 0:\n print(f'Epoch {epoch + 1} Batch {batch} \\\n Loss {train_loss.result():.4f} \\\n Accuracy {train_accuracy.result():.4f}')\n\n # Log training metric on tensorboard\n with train_summary_writer.as_default():\n tf.summary.scalar('loss', train_loss.result(), step=epoch)\n tf.summary.scalar('accuracy', train_accuracy.result(), step=epoch)\n\n # Evaluation\n for inp, tar in test_batches:\n test_step(inp, tar)\n print(f'--- Test Metrics: Epoch {epoch + 1} \\\n Loss {test_loss.result():.4f} \\\n Accuracy {test_accuracy.result():.4f} ---')\n\n with test_summary_writer.as_default():\n tf.summary.scalar('loss', test_loss.result(), step=epoch)\n tf.summary.scalar('accuracy', test_accuracy.result(), step=epoch)\n\n if (epoch + 1) % 5 == 0:\n ckpt_save_path = ckpt_manager.save()\n print (f'Saving checkpoint for epoch {epoch+1} at {ckpt_save_path}')\n\n print(f'Epoch {epoch + 1} Loss {train_loss.result():.4f} \\\n Accuracy {train_accuracy.result():.4f}')\n\n print(f'Time taken for 1 epoch: {time.time() - start:.2f} secs\\n')\n"
] |
[
[
"tensorflow.keras.metrics.Mean",
"tensorflow.train.CheckpointManager",
"numpy.sum",
"tensorflow.summary.create_file_writer",
"tensorflow.train.Checkpoint"
]
] |
marchirschvogel/ambit
|
[
"9c21852d2c7c562b7accdd34025fc6b829eb1d3e"
] |
[
"modules/flow0d/cardiovascular0D.py"
] |
[
"#!/usr/bin/env python3\n\n# Copyright (c) 2019-2022, Dr.-Ing. Marc Hirschvogel\n# All rights reserved.\n\n# This source code is licensed under the BSD-style license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport sys, time\nimport numpy as np\nimport sympy as sp\n\nfrom mpiroutines import allgather_vec_entry\nfrom oderoutines import ode\n\n\nclass cardiovascular0Dbase(ode):\n \n def __init__(self, init=True, comm=None):\n \n # initialize base class\n ode.__init__(self, init=init, comm=comm)\n \n self.T_cycl = 0 # duration of one cardiac cycle (gets overridden by derived syspul* classes)\n\n \n # check for cardiac cycle periodicity \n def cycle_check(self, var, varTc, varTc_old, t, cycle, cyclerr, eps_periodic, check='allvar', inioutpath=None, nm='', induce_pert_after_cycl=-1):\n \n if isinstance(varTc, np.ndarray): vs, ve = 0, len(varTc)\n else: vs, ve = var.getOwnershipRange()\n\n is_periodic = False\n \n if self.T_cycl > 0. and np.isclose(t, self.T_cycl):\n \n varTc[vs:ve] = var[vs:ve]\n \n if check is not None: is_periodic = self.check_periodic(varTc, varTc_old, eps_periodic, check, cyclerr)\n \n # definitely should not be True if we've not yet surpassed the \"disease induction\" cycle\n if cycle[0] <= induce_pert_after_cycl:\n is_periodic = False\n \n # write \"periodic\" initial conditions in case we want to restart from this model in another simulation\n if is_periodic and inioutpath is not None:\n self.write_initial(inioutpath, nm, varTc_old, varTc)\n \n varTc_old[vs:ve] = varTc[vs:ve]\n \n # update cycle counter\n cycle[0] += 1\n\n return is_periodic\n\n\n # some perturbations/diseases we want to simulate (mr: mitral regurgitation, ms: mitral stenosis, ar: aortic regurgitation, as: aortic stenosis)\n def induce_perturbation(self, perturb_type, perturb_factor):\n\n if perturb_type=='mr': self.R_vin_l_max *= perturb_factor\n if perturb_type=='ms': self.R_vin_l_min *= perturb_factor\n if perturb_type=='ar': self.R_vout_l_max *= perturb_factor\n if perturb_type=='as': self.R_vout_l_min *= perturb_factor\n\n # arrays need re-initialization, expressions have to be re-set\n self.setup_arrays(), self.set_compartment_interfaces()\n self.equation_map(), self.set_stiffness(), self.lambdify_expressions()\n\n \n # set pressure function for 3D FEM model (FEniCS)\n def set_pressure_fem(self, var, ids, pr0D, p0Da):\n \n # set pressure functions\n for i in range(len(ids)):\n pr0D.val = -allgather_vec_entry(var, ids[i], self.comm)\n p0Da[i].interpolate(pr0D.evaluate)\n\n\n # set valve q(p) relationship\n def valvelaw(self, p, popen, Rmin, Rmax, vparams, topen, tclose):\n\n if vparams[0]=='pwlin_pres': # piecewise linear with resistance depending on pressure difference\n R = sp.Piecewise( (Rmax, p < popen), (Rmin, p >= popen) )\n vl = (popen - p) / R\n elif vparams[0]=='pwlin_time': # piecewise linear with resistance depending on timing\n if topen > tclose: R = sp.Piecewise( (Rmax, sp.And(self.t_ < topen, self.t_ >= tclose)), (Rmin, sp.Or(self.t_ >= topen, self.t_ < tclose)) )\n else: R = sp.Piecewise( (Rmax, sp.Or(self.t_ < topen, self.t_ >= tclose)), (Rmin, sp.And(self.t_ >= topen, self.t_ < tclose)) )\n vl = (popen - p) / R\n elif vparams[0]=='smooth_pres_resistance': # smooth resistance value\n R = 0.5*(Rmax - Rmin)*(sp.tanh((popen - p)/vparams[-1]) + 1.) + Rmin\n vl = (popen - p) / R \n elif vparams[0]=='smooth_pres_momentum': # smooth q(p) relationship\n # interpolation by cubic spline in epsilon interval\n p0 = (popen-vparams[-1]/2. - popen)/Rmax\n p1 = (popen+vparams[-1]/2. - popen)/Rmin\n m0 = 1./Rmax\n m1 = 1./Rmin\n s = (p - (popen-vparams[-1]/2.))/vparams[-1]\n # spline ansatz functions\n h00 = 2.*s**3. - 3*s**2. + 1.\n h01 = -2.*s**3. + 3*s**2.\n h10 = s**3. - 2.*s**2. + s\n h11 = s**3. - s**2.\n # spline\n c = h00*p0 + h10*m0*vparams[-1] + h01*p1 + h11*m1*vparams[-1]\n vl = sp.Piecewise( ((popen - p)/Rmax, p < popen-vparams[-1]/2), (-c, sp.And(p >= popen-vparams[-1]/2., p < popen+vparams[-1]/2.)), ((popen - p)/Rmin, p >= popen+vparams[-1]/2.) )\n elif vparams[0]=='pw_pres_regurg':\n vl = sp.Piecewise( (vparams[1]*vparams[2]*sp.sqrt(popen - p), p < popen), ((popen - p) / Rmin, p >= popen) )\n else:\n raise NameError(\"Unknown valve law %s!\" % (vparams[0]))\n \n vlaw = vl\n if popen is not sp.S.Zero:\n res = 1./sp.diff(vl,popen)\n else:\n res = sp.S.One\n \n return vlaw, res\n\n\n # set compartment interfaces according to case and coupling quantity (can be volume, flux, or pressure)\n def set_compartment_interfaces(self):\n \n # loop over chambers\n for i, ch in enumerate(['lv','rv','la','ra', 'ao']):\n \n if ch == 'lv': chn = 'v_l'\n if ch == 'rv': chn = 'v_r'\n if ch == 'la': chn = 'at_l'\n if ch == 'ra': chn = 'at_r'\n if ch == 'ao': chn = 'aort_sys'\n\n if self.chmodels[ch]['type']=='0D_elast' or self.chmodels[ch]['type']=='0D_elast_prescr':\n self.switch_V[i] = 1\n \n elif self.chmodels[ch]['type']=='0D_rigid':\n self.switch_V[i] = 0\n \n elif self.chmodels[ch]['type']=='prescribed':\n if self.cq[i] == 'volume':\n self.switch_V[i] = 1\n self.cname.append('V_'+chn)\n elif self.cq[i] == 'flux':\n self.switch_V[i] = 0\n self.cname.append('Q_'+chn)\n else:\n raise NameError(\"Unknown coupling quantity!\")\n \n elif self.chmodels[ch]['type']=='3D_solid':\n if self.cq[i] == 'volume':\n self.v_ids.append(self.vindex_ch[i]) # variable indices for coupling\n self.c_ids.append(self.cindex_ch[i]) # coupling quantity indices for coupling\n self.cname.append('V_'+chn)\n self.switch_V[i], self.vname[i] = 1, 'p_'+chn\n elif self.cq[i] == 'flux':\n self.cname.append('Q_'+chn)\n self.switch_V[i], self.vname[i] = 0, 'p_'+chn\n self.v_ids.append(self.vindex_ch[i]) # variable indices for coupling\n self.c_ids.append(self.cindex_ch[i]) # coupling quantity indices for coupling\n elif self.cq[i] == 'pressure':\n if self.vq[i] == 'volume':\n self.switch_V[i], self.vname[i] = 1, 'V_'+chn\n elif self.vq[i] == 'flux':\n self.switch_V[i], self.vname[i] = 0, 'Q_'+chn\n else:\n raise ValueError(\"Variable quantity has to be volume or flux!\")\n self.cname.append('p_'+chn)\n self.si[i] = 1 # switch indices of pressure / outflux\n self.v_ids.append(self.vindex_ch[i]-self.si[i]) # variable indices for coupling\n else:\n raise NameError(\"Unknown coupling quantity!\")\n \n # 3D fluid currently only working with Cheart!\n elif self.chmodels[ch]['type']=='3D_fluid':\n assert(self.cq[i] == 'pressure')\n self.switch_V[i], self.vname[i] = 0, 'Q_'+chn\n if ch != 'ao': self.si[i] = 1 # switch indices of pressure / outflux\n #self.v_ids.append(self.vindex_ch[i]-self.si[i]) # variable indices for coupling\n # add inflow pressures to coupling name prefixes\n for m in range(self.chmodels[ch]['num_inflows']):\n self.cname.append('p_'+chn+'_i'+str(m+1)+'')\n # add outflow pressures to coupling name prefixes\n for m in range(self.chmodels[ch]['num_outflows']):\n self.cname.append('p_'+chn+'_o'+str(m+1)+'')\n \n else:\n raise NameError(\"Unknown chamber model for chamber %s!\" % (ch))\n\n\n # set coupling state (populate x and c vectors with Sympy symbols) according to case and coupling quantity (can be volume, flux, or pressure)\n def set_coupling_state(self, ch, chvars, chfncs=[]):\n \n if ch == 'lv': V_unstressed, i = self.V_v_l_u, 0\n if ch == 'rv': V_unstressed, i = self.V_v_r_u, 1\n if ch == 'la': V_unstressed, i = self.V_at_l_u, 2\n if ch == 'ra': V_unstressed, i = self.V_at_r_u, 3\n if ch == 'ao': V_unstressed, i = self.V_ar_sys_u, 4\n \n # \"distributed\" p variables\n num_pdist = len(chvars)-1\n\n # time-varying elastances\n if self.chmodels[ch]['type']=='0D_elast' or self.chmodels[ch]['type']=='0D_elast_prescr':\n chvars['VQ'] = chvars['pi1']/chfncs[0] + V_unstressed # V = p/E(t) + V_u\n self.fnc_.append(chfncs[0])\n \n # all \"distributed\" p are equal to \"main\" p of chamber (= pi1)\n for k in range(10): # no more than 10 distributed p's allowed\n if 'pi'+str(k+1)+'' in chvars.keys(): chvars['pi'+str(k+1)+''] = chvars['pi1']\n if 'po'+str(k+1)+'' in chvars.keys(): chvars['po'+str(k+1)+''] = chvars['pi1']\n\n # rigid\n elif self.chmodels[ch]['type']=='0D_rigid':\n chvars['VQ'] = 0\n \n # all \"distributed\" p are equal to \"main\" p of chamber (= pi1)\n for k in range(10): # no more than 10 distributed p's allowed\n if 'pi'+str(k+1)+'' in chvars.keys(): chvars['pi'+str(k+1)+''] = chvars['pi1']\n if 'po'+str(k+1)+'' in chvars.keys(): chvars['po'+str(k+1)+''] = chvars['pi1']\n\n # 3D solid mechanics model, or 0D prescribed volume/flux/pressure (non-primary variables!)\n elif self.chmodels[ch]['type']=='3D_solid' or self.chmodels[ch]['type']=='prescribed':\n\n # all \"distributed\" p are equal to \"main\" p of chamber (= pi1)\n for k in range(10): # no more than 10 distributed p's allowed\n if 'pi'+str(k+1)+'' in chvars.keys(): chvars['pi'+str(k+1)+''] = chvars['pi1']\n if 'po'+str(k+1)+'' in chvars.keys(): chvars['po'+str(k+1)+''] = chvars['pi1']\n\n if self.cq[i] == 'volume' or self.cq[i] == 'flux':\n self.c_.append(chvars['VQ']) # V or Q\n if self.cq[i] == 'pressure':\n self.x_[self.vindex_ch[i]-self.si[i]] = chvars['VQ'] # V or Q\n self.c_.append(chvars['pi1'])\n\n # 3D fluid mechanics model\n elif self.chmodels[ch]['type']=='3D_fluid': # also for 2D FEM models\n \n assert(self.cq[i] == 'pressure' and self.vq[i] == 'flux')\n\n self.x_[self.vindex_ch[i]-self.si[i]] = chvars['VQ'] # Q of chamber is now variable\n\n # all \"distributed\" p that are not coupled are set to first inflow p\n for k in range(self.chmodels[ch]['num_inflows'],10):\n if 'pi'+str(k+1)+'' in chvars.keys(): chvars['pi'+str(k+1)+''] = chvars['pi1']\n\n # if no inflow is present, set to zero\n if self.chmodels[ch]['num_inflows']==0: chvars['pi1'] = sp.S.Zero\n\n # now add inflow pressures to coupling array\n for m in range(self.chmodels[ch]['num_inflows']):\n self.c_.append(chvars['pi'+str(m+1)+''])\n \n # all \"distributed\" p that are not coupled are set to first outflow p\n for k in range(self.chmodels[ch]['num_outflows'],10):\n if 'po'+str(k+1)+'' in chvars.keys(): chvars['po'+str(k+1)+''] = chvars['po1']\n \n # if no outflow is present, set to zero\n if self.chmodels[ch]['num_outflows']==0: chvars['po1'] = sp.S.Zero\n\n # now add outflow pressures to coupling array\n for m in range(self.chmodels[ch]['num_outflows']):\n self.c_.append(chvars['po'+str(m+1)+''])\n\n else:\n raise NameError(\"Unknown chamber model for chamber %s!\" % (ch))\n \n\n # evaluate time-dependent state of chamber (for 0D elastance models)\n def evaluate_chamber_state(self, y, t):\n \n chamber_funcs=[]\n\n ci=0\n for i, ch in enumerate(['lv','rv','la','ra']):\n\n if self.chmodels[ch]['type']=='0D_elast':\n \n if ch == 'lv': E_max, E_min = self.E_v_max_l, self.E_v_min_l\n if ch == 'rv': E_max, E_min = self.E_v_max_r, self.E_v_min_r\n if ch == 'la': E_max, E_min = self.E_at_max_l, self.E_at_min_l\n if ch == 'ra': E_max, E_min = self.E_at_max_r, self.E_at_min_r\n\n # time-varying elastance model (y should be normalized activation function provided by user)\n E_ch_t = (E_max - E_min) * y[ci] + E_min\n \n chamber_funcs.append(E_ch_t)\n \n ci+=1\n\n elif self.chmodels[ch]['type']=='0D_elast_prescr':\n \n E_ch_t = y[ci]\n \n chamber_funcs.append(E_ch_t)\n \n ci+=1\n \n else:\n \n pass\n \n return chamber_funcs\n\n\n # initialize Lagrange multipliers for monolithic Lagrange-type coupling (FEniCS)\n def initialize_lm(self, var, iniparam):\n \n for i, ch in enumerate(['lv','rv','la','ra']):\n \n if self.chmodels[ch]['type']=='3D_solid':\n \n if ch=='lv':\n if 'p_v_l_0' in iniparam.keys(): var[i] = iniparam['p_v_l_0']\n if ch=='rv':\n if 'p_v_r_0' in iniparam.keys(): var[i] = iniparam['p_v_r_0']\n if ch=='la':\n if 'p_at_l_0' in iniparam.keys(): var[i] = iniparam['p_at_l_0']\n if ch=='ra':\n if 'p_at_r_0' in iniparam.keys(): var[i] = iniparam['p_at_r_0']\n"
] |
[
[
"numpy.isclose"
]
] |
sophiaas/alphacsc
|
[
"402b8f6c8ee4ba9c86e9da0e2073d900cf8da207"
] |
[
"alphacsc/other/sporco/examples/scripts/tv/tvl2den_clr.py"
] |
[
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# This file is part of the SPORCO package. Details of the copyright\n# and user license can be found in the 'LICENSE.txt' file distributed\n# with the package.\n\n\"\"\"\nColour ℓ2-TV Denoising\n======================\n\nThis example demonstrates the use of class :class:`.tvl2.TVL2Denoise` for removing Gaussian white noise from a colour image using Total Variation regularization with an ℓ2 data fidelity term (ℓ2-TV denoising).\n\"\"\"\n\n\nfrom __future__ import print_function\nfrom builtins import input\nfrom builtins import range\n\nimport numpy as np\n\nfrom sporco.admm import tvl2\nfrom sporco import util\nfrom sporco import metric\nfrom sporco import plot\n\n\n\"\"\"\nLoad reference image.\n\"\"\"\n\nimg = util.ExampleImages().image('monarch.png', scaled=True,\n idxexp=np.s_[:,160:672])\n\n\n\"\"\"\nConstruct test image corrupted by Gaussian white noise with a 0.05 standard deviation.\n\"\"\"\n\nnp.random.seed(12345)\nimgn = img + np.random.normal(0.0, 0.05, img.shape)\n\n\n\"\"\"\nSet regularization parameter and options for ℓ2-TV denoising solver. The regularization parameter used here has been manually selected for good performance.\n\"\"\"\n\nlmbda = 0.04\nopt = tvl2.TVL2Denoise.Options({'Verbose': True, 'MaxMainIter': 200,\n 'gEvalY': False, 'AutoRho': {'Enabled': True}})\n\n\n\"\"\"\nCreate solver object and solve, returning the the denoised image ``imgr``.\n\"\"\"\n\nb = tvl2.TVL2Denoise(imgn, lmbda, opt)\nimgr = b.solve()\n\n\n\"\"\"\nDisplay solve time and denoising performance.\n\"\"\"\n\nprint(\"TVL2Denoise solve time: %5.2f s\" % b.timer.elapsed('solve'))\nprint(\"Noisy image PSNR: %5.2f dB\" % metric.psnr(img, imgn))\nprint(\"Denoised image PSNR: %5.2f dB\" % metric.psnr(img, imgr))\n\n\n\"\"\"\nDisplay reference, corrupted, and denoised images.\n\"\"\"\n\nfig = plot.figure(figsize=(20, 5))\nplot.subplot(1, 3, 1)\nplot.imview(img, fig=fig, title='Reference')\nplot.subplot(1, 3, 2)\nplot.imview(imgn, fig=fig, title='Corrupted')\nplot.subplot(1, 3, 3)\nplot.imview(imgr, fig=fig, title=r'Restored ($\\ell_2$-TV)')\nfig.show()\n\n\n\"\"\"\nGet iterations statistics from solver object and plot functional value, ADMM primary and dual residuals, and automatically adjusted ADMM penalty parameter against the iteration number.\n\"\"\"\n\nits = b.getitstat()\nfig = plot.figure(figsize=(20, 5))\nplot.subplot(1, 3, 1)\nplot.plot(its.ObjFun, fig=fig, xlbl='Iterations', ylbl='Functional')\nplot.subplot(1, 3, 2)\nplot.plot(np.vstack((its.PrimalRsdl, its.DualRsdl)).T, fig=fig,\n ptyp='semilogy', xlbl='Iterations', ylbl='Residual',\n lgnd=['Primal', 'Dual'])\nplot.subplot(1, 3, 3)\nplot.plot(its.Rho, fig=fig, xlbl='Iterations', ylbl='Penalty Parameter')\nfig.show()\n\n\n# Wait for enter on keyboard\ninput()\n"
] |
[
[
"numpy.random.seed",
"numpy.random.normal",
"numpy.vstack"
]
] |
francoispichard/covid_twitter_bert_imbalanced
|
[
"c122a85bdcd16b051179146397ee94f3e0c597c0"
] |
[
"utils/misc.py"
] |
[
"import logging\nimport json\nimport os\nimport argparse\nimport tensorflow as tf\nimport numpy as np\nfrom contextlib import contextmanager\nimport fcntl\n\n\nlogger = logging.getLogger(__name__)\n\ndef save_to_json(data, f_name):\n with tf.io.gfile.GFile(f_name, 'w') as writer:\n writer.write(json.dumps(data, cls=JSONEncoder, indent=4))\n\nclass JSONEncoder(json.JSONEncoder):\n def default(self, obj):\n if isinstance(obj, np.integer):\n return int(obj)\n elif isinstance(obj, np.floating):\n return float(obj)\n elif isinstance(obj, np.ndarray):\n return obj.tolist()\n else:\n return super(MyEncoder, self).default(obj)\n\nclass ArgParseDefault(argparse.ArgumentParser):\n \"\"\"Simple wrapper which shows defaults in help\"\"\"\n def __init__(self, **kwargs):\n super().__init__(**kwargs, formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n\ndef add_bool_arg(parser, name, default=False, help=''):\n group = parser.add_mutually_exclusive_group(required=False)\n group.add_argument('--' + name, dest=name, action='store_true', help=help)\n group.add_argument('--do_not_' + name, dest=name, action='store_false')\n parser.set_defaults(**{name: default})\n\n@contextmanager\ndef file_lock(fd):\n \"\"\" Locks FD before entering the context, always releasing the lock. \"\"\"\n try:\n fcntl.flock(fd, fcntl.LOCK_EX)\n yield\n finally:\n fcntl.flock(fd, fcntl.LOCK_UN)\n"
] |
[
[
"tensorflow.io.gfile.GFile"
]
] |
cemkaraoguz/UFLDLTutorial
|
[
"4046b7d23642b3af3522af2ef1fce4b79fd9af7e"
] |
[
"common/Visualization.py"
] |
[
"''' UFL_Visualization.py\n\t\n\tMethods for visualization\n\t\n\tAuthor: Cem Karaoguz\n\tDate: 19.02.2015\n\tVersion: 1.0\n'''\n\nimport os, struct, sys\nimport numpy as np\nimport pylab as pl\n\ndef displayNetwork(A, kernelWidth=-1, kernelHeight=-1, opt_normalize=True, opt_graycolor=True, cols=-1, opt_colmajor=False):\n\t'''\n\t\tThis function visualizes filters in matrix A. Each column of A is a\n\t\tfilter. We will reshape each column into a square image and visualizes\n\t\ton each cell of the visualization panel. \n\t\t\n\t\topt_normalize: whether we need to normalize the filter so that all of\n\t\tthem can have similar contrast. Default value is true.\n\t\topt_graycolor: whether we use gray as the heat map. Default is true.\n\t\tcols: how many columns are there in the display. Default value is 4.\n\t\topt_colmajor: you can switch convention to row major for A. In that\n\t\tcase, each row of A is a filter. Default value is false.\n\t'''\n\n\t# rescale\n\tA = A - np.mean(A[:]);\n\n\t# compute rows, cols\n\t[L, M] = np.shape(A);\n\tif (kernelWidth<0 or kernelHeight<0):\n\t\t#sz = sqrt(L);\n\t\tw = int(np.sqrt(L));\n\t\th = int(np.sqrt(L));\n\telse:\n\t\tw = kernelWidth;\n\t\th = kernelHeight;\n\t\t\n\tbuf = 1;\n\t\t\n\tif cols<=0:\n\t\tif np.floor(np.sqrt(M))**2 != M:\n\t\t\tn = np.ceil(np.sqrt(M));\n\t\t\twhile np.mod(M, n)!=0 and n<1.2*np.sqrt(M):\n\t\t\t\tn = n+1;\n\t\t\tm = int(np.ceil(M/n));\n\t\telse:\n\t\t\tn = int(np.sqrt(M));\n\t\t\tm = int(n);\n\telse:\n\t\tn = int(cols);\n\t\tm = int(np.ceil(M/n));\n\n\tarray = -1 * np.ones([buf+m*(w+buf), buf+n*(h+buf)]);\n\t\n\tif ~opt_graycolor:\n\t\tarray = 0.1 * array;\n\t\n\tm = int(m);\n\tn = int(n);\n\tif ~opt_colmajor:\n\t\tk = 0;\n\t\tfor i in range(m):\n\t\t\tfor j in range(n):\n\t\t\t\tif (k>=M): \n\t\t\t\t\tcontinue; \n\t\t\t\tclim = np.max(abs(A[:,k]));\n\t\t\t\tif opt_normalize:\n\t\t\t\t\tarray[buf+(i)*(w+buf):buf+(i)*(w+buf)+w, buf+(j)*(h+buf):buf+(j)*(h+buf)+h] = np.reshape(A[:,k], [w, h])/clim;\n\t\t\t\telse:\n\t\t\t\t\tarray[buf+(i)*(w+buf):buf+(i)*(w+buf)+w, buf+(j)*(h+buf):buf+(j)*(h+buf)+h] = np.reshape(A[:,k], [w, h])/np.max(abs(A[:]));\n\t\t\t\tk = k+1;\n\t\t\t#end j\n\t\t#end i\n\telse:\n\t\tk = 0;\n\t\tfor j in range(n):\n\t\t\tfor i in range(m):\n\t\t\t\tif k>=M: \n\t\t\t\t\tcontinue; \n\t\t\t\tclim = np.max(abs(A[:,k]));\n\t\t\t\tif opt_normalize:\n\t\t\t\t\tarray[buf+(i)*(w+buf):buf+(i)*(w+buf)+w, buf+(j)*(h+buf):buf+(j)*(h+buf)+h] = np.reshape(A[:,k], [w, h])/clim;\n\t\t\t\telse:\n\t\t\t\t\tarray[buf+(i)*(w+buf):buf+(i)*(w+buf)+w, buf+(j)*(h+buf):buf+(j)*(h+buf)+h] = np.reshape(A[:,k], [w, h])/np.max(abs(A[:]));\n\t\t\t\tk = k+1;\n\t\t\t#end i\n\t\t#end j\n\t#end\n\n\tif opt_graycolor:\n\t\t#h = pl.imshow(array,'EraseMode','none',[-1 1]);\n\t\th = pl.imshow(array, cmap='gray');\n\telse:\n\t\t#h = pl.imshow(array,'EraseMode','none',[-1 1]);\n\t\th = pl.imshow(array);\n\n\tpl.axis('image')\n\tpl.axis('off')\n\n\tpl.show();\n\ndef displayColorNetwork(A):\n\t''' \n\tDisplay receptive field(s) or basis vector(s) for image patches \n\tA\t: the basis, with patches as column vectors\n\tIn case the midpoint is not set at 0, we shift it dynamically\n\t'''\n\tif np.min(A[:]) >= 0:\n\t\tA = A - np.mean(A[:]);\n\t\n\tcols = np.round(np.sqrt(A.shape[1]));\n\n\tchannel_size = A.shape[0]/3;\n\tdim = np.sqrt(channel_size);\n\tdimp = dim+1;\n\trows = np.ceil(A.shape[1]/cols);\n\tB = A[0:channel_size, :];\n\tC = A[channel_size:channel_size*2, :];\n\tD = A[2*channel_size:channel_size*3, :];\n\tB = B/(np.ones((B.shape[0], 1)) * np.max(np.abs(B)));\n\tC = C/(np.ones((C.shape[0], 1)) * np.max(np.abs(C)));\n\tD = D/(np.ones((D.shape[0], 1)) * np.max(np.abs(D)));\n\t# Initialization of the image\n\tI = np.ones((dim*rows+rows-1,dim*cols+cols-1,3));\n\n\t#Transfer features to this image matrix\n\trows = int(rows)\n\tcols = int(cols)\n\tfor i in range(rows):\n\t\tfor j in range(cols):\n\t\t \n\t\t\tif i*cols+j+1 > B.shape[1]:\n\t\t\t\tbreak\n\t\t\n\t\t# This sets the patch\n\t\tI[i*dimp:i*dimp+dim, j*dimp:j*dimp+dim, 0] = np.reshape(B[:,i*cols+j],[dim, dim]);\n\t\tI[i*dimp:i*dimp+dim, j*dimp:j*dimp+dim, 1] = np.reshape(C[:,i*cols+j],[dim, dim]);\n\t\tI[i*dimp:i*dimp+dim, j*dimp:j*dimp+dim, 2] = np.reshape(D[:,i*cols+j],[dim, dim]);\n\n\tI = I + 1;\n\tI = I / 2;\n\n\tpl.imshow(I);\n\tpl.axis('equal')\n\tpl.axis('off')\n\tpl.show();\n\t\nif __name__ == '__main__':\n\t\n\t#W = np.random.rand(8*8, 16)\n\tW = np.zeros((8,8, 16))\n\tW[4,:,0] = 1;\n\tW[:,4,1] = 1;\n\tW = np.reshape(W, [8*8, 16])\n\tdisplayWeights(W)\n\t\n\t\n"
] |
[
[
"numpy.ceil",
"numpy.reshape",
"numpy.zeros",
"numpy.ones",
"numpy.min",
"numpy.shape",
"numpy.mean",
"numpy.sqrt",
"numpy.abs",
"numpy.mod"
]
] |
latimerb/sonata
|
[
"ed14cce11e01c920f722216ae338c16297ebd919"
] |
[
"examples/300_cells/build_network.py"
] |
[
"import os\nimport numpy as np\n\nfrom bmtk.builder import NetworkBuilder\nfrom bmtk.builder.bionet import SWCReader\nfrom bmtk.utils.io.spike_trains import PoissonSpikesGenerator\nfrom bmtk.builder.aux.node_params import positions_columinar, xiter_random\n\nbuild_recurrent_edges = True\n\nprint('Building internal network')\n# List of non-virtual cell models\ncell_models = [\n {\n 'model_name': 'Scnn1a', 'ei': 'e',\n 'morphology': 'Scnn1a_473845048_m',\n 'model_template': 'nml:Cell_472363762.cell.nml'\n },\n {\n 'model_name': 'Rorb', 'ei': 'e',\n 'morphology': 'Rorb_325404214_m',\n 'model_template': 'nml:Cell_473863510.cell.nml'\n },\n {\n 'model_name': 'Nr5a1', 'ei': 'e',\n 'morphology': 'Nr5a1_471087815_m',\n 'model_template': 'nml:Cell_473863035.cell.nml'\n },\n {\n 'model_name': 'PV1', 'ei': 'i',\n 'morphology': 'Pvalb_470522102_m',\n 'model_template': 'nml:Cell_472912177.cell.nml'\n },\n {\n 'model_name': 'PV2', 'ei': 'i',\n 'morphology': 'Pvalb_469628681_m',\n 'model_template': 'nml:Cell_473862421.cell.nml'\n }\n]\n\nmorphologies = {p['model_name']: SWCReader(os.path.join('../shared_components/morphologies',\n '{}.swc'.format(p['morphology'])))\n for p in cell_models}\ndef build_edges(src, trg, sections=['basal', 'apical'], dist_range=[50.0, 150.0]):\n \"\"\"Function used to randomly assign a synaptic location based on the section (soma, basal, apical) and an\n arc-length dist_range from the soma. This function should be passed into the network and called during the build\n process.\n\n :param src: source cell (dict)\n :param trg: target cell (dict)\n :param sections: list of target cell sections to synapse onto\n :param dist_range: range (distance from soma center) to place\n :return:\n \"\"\"\n # Get morphology and soma center for the target cell\n swc_reader = morphologies[trg['model_name']]\n target_coords = [trg['x'], trg['y'], trg['z']]\n\n sec_ids, sec_xs = swc_reader.choose_sections(sections, dist_range) # randomly choose sec_ids\n coords = swc_reader.get_coord(sec_ids, sec_xs, soma_center=target_coords) # get coords of sec_ids\n dist = swc_reader.get_dist(sec_ids)\n swctype = swc_reader.get_type(sec_ids)\n return sec_ids, sec_xs, coords[0][0], coords[0][1], coords[0][2], dist[0], swctype[0]\n\n\n# Build a network of 300 biophysical cells to simulate\ninternal = NetworkBuilder(\"internal\")\nfor i, model_props in enumerate(cell_models):\n n_cells = 80 if model_props['ei'] == 'e' else 30 # 80% excitatory, 20% inhib\n\n # Randomly get positions uniformly distributed in a column\n positions = positions_columinar(N=n_cells, center=[0, 10.0, 0], max_radius=50.0, height=200.0)\n\n internal.add_nodes(N=n_cells,\n x=positions[:, 0], y=positions[:, 1], z=positions[:, 2],\n rotation_angle_yaxis=xiter_random(N=n_cells, min_x=0.0, max_x=2 * np.pi), # randomly rotate y axis\n model_type='biophysical',\n model_processing='aibs_perisomatic',\n **model_props)\n\nif build_recurrent_edges:\n def n_connections(src, trg, prob=0.5, min_syns=2, max_syns=7):\n return 0 if np.random.uniform() > prob else np.random.randint(min_syns, max_syns)\n\n # exc --> exc connections\n cm = internal.add_edges(source={'ei': 'e'}, target={'ei': 'e'},\n connection_rule=n_connections,\n connection_params={'prob': 0.2},\n #connection_rule=lambda *_: np.random.randint(0, 7),\n dynamics_params='AMPA_ExcToExc.json',\n model_template='Exp2Syn',\n delay=2.0)\n cm.add_properties('syn_weight', rule=6.0e-05, dtypes=np.float)\n cm.add_properties(['sec_id', 'sec_x', 'pos_x', 'pos_y', 'pos_z', 'dist', 'type'],\n rule=build_edges,\n rule_params={'sections': ['basal', 'apical'], 'dist_range': [30.0, 150.0]},\n dtypes=[np.int32, np.float, np.float, np.float, np.float, np.float, np.uint8])\n\n # exc --> inh connections\n cm = internal.add_edges(source={'ei': 'e'}, target={'ei': 'i'},\n connection_rule=n_connections,\n dynamics_params='AMPA_ExcToInh.json',\n model_template='Exp2Syn',\n delay=2.0)\n cm.add_properties('syn_weight', rule=0.0006, dtypes=np.float)\n cm.add_properties(['sec_id', 'sec_x', 'pos_x', 'pos_y', 'pos_z', 'dist', 'type'],\n rule=build_edges,\n rule_params={'sections': ['somatic', 'basal'], 'dist_range': [0.0, 1.0e+20]},\n dtypes=[np.int32, np.float, np.float, np.float, np.float, np.float, np.uint8])\n\n # inh --> exc connections\n cm = internal.add_edges(source={'ei': 'i'}, target={'ei': 'i'},\n connection_rule=n_connections,\n #connection_rule=lambda *_: np.random.randint(0, 4),\n dynamics_params='GABA_InhToExc.json',\n model_template='Exp2Syn',\n delay=2.0)\n cm.add_properties('syn_weight', rule=0.002, dtypes=np.float)\n cm.add_properties(['sec_id', 'sec_x', 'pos_x', 'pos_y', 'pos_z', 'dist', 'type'],\n rule=build_edges,\n rule_params={'sections': ['somatic', 'basal', 'apical'], 'dist_range': [0.0, 50.0]},\n dtypes=[np.int32, np.float, np.float, np.float, np.float, np.float, np.uint8])\n\n # inh --> inh connections\n cm = internal.add_edges(source={'ei': 'i'}, target={'ei': 'i'},\n connection_rule=n_connections,\n dynamics_params='GABA_InhToInh.json',\n model_template='Exp2Syn',\n delay=2.0)\n cm.add_properties('syn_weight', rule=0.00015, dtypes=np.float)\n cm.add_properties(['sec_id', 'sec_x', 'pos_x', 'pos_y', 'pos_z', 'dist', 'type'],\n rule=build_edges,\n rule_params={'sections': ['somatic', 'basal'], 'dist_range': [0.0, 1.0e+20]},\n dtypes=[np.int32, np.float, np.float, np.float, np.float, np.float, np.uint8])\n\n\ninternal.build()\n\nprint('Saving internal')\ninternal.save(output_dir='network')\n\n\nprint('Building external connections')\nexternal = NetworkBuilder(\"external\")\nexternal.add_nodes(N=100, model_type='virtual', ei='e')\ncm = external.add_edges(target=internal.nodes(ei='e'), source=external.nodes(),\n connection_rule=lambda *_: np.random.randint(0, 5),\n dynamics_params='AMPA_ExcToExc.json',\n model_template='Exp2Syn',\n delay=2.0)\ncm.add_properties('syn_weight', rule=2.1e-4, dtypes=np.float)\ncm.add_properties(['sec_id', 'sec_x', 'pos_x', 'pos_y', 'pos_z', 'dist', 'type'],\n rule=build_edges,\n dtypes=[np.int32, np.float, np.float, np.float, np.float, np.float, np.uint8])\n\ncm = external.add_edges(target=internal.nodes(ei='i'), source=external.nodes(),\n connection_rule=lambda *_: np.random.randint(0, 5),\n dynamics_params='AMPA_ExcToInh.json',\n model_template='Exp2Syn',\n delay=2.0)\ncm.add_properties('syn_weight', rule=0.0015, dtypes=np.float)\ncm.add_properties(['sec_id', 'sec_x', 'pos_x', 'pos_y', 'pos_z', 'dist', 'type'],\n rule=build_edges,\n dtypes=[np.int32, np.float, np.float, np.float, np.float, np.float, np.uint8])\n\n\nexternal.build()\n\nprint('Saving external')\nexternal.save(output_dir='network')\n\n\n"
] |
[
[
"numpy.random.uniform",
"numpy.random.randint"
]
] |
PonderaLab/estrategia-control-covid
|
[
"dfeb311b42baf9aa0b7652ed1472b7fd78335f82"
] |
[
"coupled_dynamics/ext_params.py"
] |
[
"import numpy as np\nfrom helper_functions import *\n# from arenas_params import pg, ξ, kg\n\ndef get_ext_params( n_ig, s_i, R_ij, pg, one_minus_pg, ξ, kg ):\n\n # number of patches\n try:\n NP = np.array(n_ig).shape[0]\n except:\n NP = 1\n\n # effective population given the mobility parameters\n n_i_eff = get_n_i_eff(n_ig, R_ij, pg)\n n_ig_eff = get_n_ig_eff(n_ig, R_ij, pg)\n n_g = get_n_g(n_ig)\n\n # patch related effective density\n f_i = f(n_i_eff/s_i, ξ)\n if NP != 1:\n f_i = f_i.reshape(NP,1)\n\n # age related normalization factor\n z_g = n_g / np.dot( np.transpose(f_i), n_ig_eff )\n # precoputation of age related fixed params (number of contacts could enter the bayesian formalism later...)\n zk_g = z_g * kg\n\n ## EXTERNAL FIXED PARAMETERS\n return [zk_g, f_i, n_ig_eff]\n"
] |
[
[
"numpy.array",
"numpy.transpose"
]
] |
phy-ml/neural-solver
|
[
"4f5f5e8ab84fa2f6d759f8278683c6a70b16caec"
] |
[
"NET_Solver/geometry/meshgen.py"
] |
[
"import numpy as np\r\nfrom geometry import Annulus_Boundary\r\nfrom utils import Plot_Grid\r\nimport torch\r\nfrom geometry import *\r\nfrom utils import *\r\n\r\n\r\nclass EllipticGrid(Annulus_Boundary):\r\n def __init__(self, r_outer, r_inner, eccentricity, cg, rg, h):\r\n super().__init__(r_outer, r_inner, eccentricity)\r\n self.nx = cg\r\n self.ny = rg\r\n self.h = h\r\n self.boundary = Annulus_Boundary(r_outer, r_inner, eccentricity).__call__(cg, rg)\r\n\r\n\r\n\r\n def __call__(self):\r\n # generate the mesh for physical space\r\n x,y = self.physical_grid(tol=1e-10)\r\n\r\n # generate the computational space\r\n xi, eta = self.computation_grid()\r\n\r\n # generate derivative of the physical plane\r\n dx_dxi, dy_dxi, dx_deta, dy_deta, jac, jac_inv = self.grid_derivative(x,y)\r\n\r\n return {'x': x,\r\n 'y': y,\r\n 'xi': xi,\r\n 'eta': eta,\r\n 'dx_dxi':dx_dxi,\r\n 'dy_dxi':dy_dxi,\r\n 'dx_deta': dx_deta,\r\n 'dy_deta': dy_deta,\r\n 'jac': jac,\r\n 'jac_inv': jac_inv}\r\n\r\n def pre_processing(self):\r\n xl, yl = self.boundary['left'][0, :], self.boundary['left'][1, :]\r\n xr, yr = self.boundary['right'][0, :], self.boundary['right'][1, :]\r\n xlow, ylow = self.boundary['low'][0, :], self.boundary['low'][1, :]\r\n xtop, ytop = self.boundary['top'][0, :], self.boundary['top'][1, :]\r\n\r\n ######################################################################\r\n # combine the x and y into a 2d matrix\r\n x = np.zeros([self.ny, self.nx])\r\n y = np.zeros([self.ny, self.nx])\r\n x[:, 0] = xl\r\n y[:, 0] = yl\r\n x[:, -1] = xr\r\n y[:, -1] = yr\r\n x[0, :] = xlow\r\n y[0, :] = ylow\r\n x[-1, :] = xtop\r\n y[-1, :] = ytop\r\n\r\n return x, y\r\n\r\n def physical_grid(self, tol=1e-10):\r\n x, y = self.pre_processing()\r\n err = 2.2e-16\r\n assert x.shape == y.shape, f'Shape of X and Y does not match'\r\n count = 1\r\n A = np.ones([self.ny - 2, self.nx - 2])\r\n B = np.ones([self.ny - 2, self.nx - 2])\r\n C = np.ones([self.ny - 2, self.nx - 2])\r\n err_total = []\r\n while True:\r\n X = (A * (x[2:, 1:-1] + x[0:-2, 1:-1]) + C * (x[1:-1, 2:] + x[1:-1, 0:-2]) -\r\n B / 2 * (x[2:, 2:] + x[0:-2, 0:-2] - x[2:, 0:-2] - x[0:-2, 2:])) / 2 / (A + C)\r\n Y = (A * (y[2:, 1:-1] + y[0:-2, 1:-1]) + C * (y[1:-1, 2:] + y[1:-1, 0:-2]) -\r\n B / 2 * (y[2:, 2:] + y[0:-2, 0:-2] - y[2:, 0:-2] - y[0:-2, 2:])) / 2 / (A + C)\r\n\r\n error = np.max(np.max(np.abs(x[1:-1, 1:-1] - X)) + np.max(np.abs(y[1:-1, 1:-1] - Y)))\r\n err_total.append(error)\r\n x[1:-1, 1:-1] = X\r\n y[1:-1, 1:-1] = Y\r\n A = ((x[1:-1, 2:] - x[1:-1, 0:-2]) / 2 / self.h) ** 2 + (\r\n (y[1:-1, 2:] - y[1:-1, 0:-2]) / 2 / self.h) ** 2 + err\r\n B = (x[2:, 1:-1] - x[0:-2, 1:-1]) / 2 / self.h * (x[1:-1, 2:] - x[1:-1, 0:-2]) / 2 / self.h + (\r\n y[2:, 1:-1] - y[0:-2, 1:-1]) / 2 / self.h * (y[1:-1, 2:] - y[1:-1, 0:-2]) / 2 / self.h + err\r\n C = ((x[2:, 1:-1] - x[0:-2, 1:-1]) / 2 / self.h) ** 2 + (\r\n (y[2:, 1:-1] - y[0:-2, 1:-1]) / 2 / self.h) ** 2 + err\r\n\r\n if error < tol:\r\n #print('Mesh Converged')\r\n break\r\n pass\r\n if count > 50000:\r\n print('Mesh did not reach convergence')\r\n break\r\n pass\r\n count += 1\r\n return x, y\r\n\r\n def computation_grid(self):\r\n xi_ = np.linspace(0, self.nx - 1, self.nx)\r\n eta_ = np.linspace(0, self.ny - 1, self.ny)\r\n xi, eta = np.meshgrid(xi_, eta_)\r\n xi = xi * self.h\r\n eta = eta * self.h\r\n return xi, eta\r\n\r\n def grid_derivative(self, x, y):\r\n # create array to store the derivatives\r\n dx_dxi = np.zeros(x.shape)\r\n dx_deta = np.zeros(x.shape)\r\n dy_dxi = np.zeros(y.shape)\r\n dy_deta = np.zeros(y.shape)\r\n\r\n # compute the derivatives\r\n dx_dxi_central = (-x[:, 4:] + 8 * x[:, 3:-1] - 8 * x[:, 1:-3] + x[:, 0:-4]) / 12 / self.h\r\n dx_dxi_left = (-11 * x[:, 0:-3] + 18 * x[:, 1:-2] - 9 * x[:, 2:-1] + 2 * x[:, 3:]) / 6 / self.h\r\n dx_dxi_right = (11 * x[:, 3:] - 18 * x[:, 2:-1] + 9 * x[:, 1:-2] - 2 * x[:, 0:-3]) / 6 / self.h\r\n\r\n dy_dxi_central = (-y[:, 4:] + 8 * y[:, 3:-1] - 8 * y[:, 1:-3] + y[:, 0:-4]) / 12 / self.h\r\n dy_dxi_left = (-11 * y[:, 0:-3] + 18 * y[:, 1:-2] - 9 * y[:, 2:-1] + 2 * y[:, 3:]) / 6 / self.h\r\n dy_dxi_right = (11 * y[:, 3:] - 18 * y[:, 2:-1] + 9 * y[:, 1:-2] - 2 * y[:, 0:-3]) / 6 / self.h\r\n\r\n dx_deta_central = (-x[4:, :] + 8 * x[3:-1, :] - 8 * x[1:-3, :] + x[0:-4, :]) / 12 / self.h\r\n dx_deta_low = (-11 * x[0:-3, :] + 18 * x[1:-2, :] - 9 * x[2:-1, :] + 2 * x[3:, :]) / 6 / self.h\r\n dx_deta_up = (11 * x[3:, :] - 18 * x[2:-1, :] + 9 * x[1:-2, :] - 2 * x[0:-3, :]) / 6 / self.h\r\n\r\n dy_deta_central = (-y[4:, :] + 8 * y[3:-1, :] - 8 * y[1:-3, :] + y[0:-4, :]) / 12 / self.h\r\n dy_deta_low = (-11 * y[0:-3, :] + 18 * y[1:-2, :] - 9 * y[2:-1, :] + 2 * y[3:, :]) / 6 / self.h\r\n dy_deta_up = (11 * y[3:, :] - 18 * y[2:-1, :] + 9 * y[1:-2, :] - 2 * y[0:-3, :]) / 6 / self.h\r\n\r\n # store the central, forward and backward derivatives in a single array\r\n dx_dxi[:, 2:-2] = dx_dxi_central\r\n dx_dxi[:, 0:2] = dx_dxi_left[:, 0:2]\r\n dx_dxi[:, -2:] = dx_dxi_right[:, -2:]\r\n\r\n dy_dxi[:, 2:-2] = dy_dxi_central\r\n dy_dxi[:, 0:2] = dy_dxi_left[:, 0:2]\r\n dy_dxi[:, -2:] = dy_dxi_right[:, -2:]\r\n\r\n dx_deta[2:-2, :] = dx_deta_central\r\n dx_deta[0:2, :] = dx_deta_low[0:2, :]\r\n dx_deta[-2:, :] = dx_deta_up[-2:, :]\r\n\r\n dy_deta[2:-2, :] = dy_deta_central\r\n dy_deta[0:2, :] = dy_deta_low[0:2, :]\r\n dy_deta[-2:, :] = dy_deta_up[-2:, :]\r\n\r\n # compute jacobian\r\n jac = dx_dxi * dy_deta - dx_deta * dy_dxi\r\n\r\n # inverse of jacobian\r\n jac_inv = 1 / jac\r\n\r\n return dx_dxi, dy_dxi, dx_deta, dy_deta, jac, jac_inv\r\n\r\n\r\nif __name__ == '__main__':\r\n cg, rg = 70, 40\r\n h = 0.01\r\n anulus = EllipticGrid(1, 0.4, -0.99, cg, rg, h)()\r\n x, y = anulus['x'], anulus['y']\r\n print(x.shape, y.shape)\r\n\r\n Plot_Grid(x, y, cg, rg)\r\n\r\n#\r\n# class TFI:\r\n# def __init__(self, xi, eta, annulus, Boundary=False):\r\n# \"\"\"\r\n# Transfinite Interpolation for generating grid using analytical function\r\n# This Function maps the complex physical space into cartesian rectangular domain\r\n#\r\n# # NOTE the input Xi and Eta should be meshed before using in this function\r\n#\r\n# xi_, eta_ = np.linspace(0,1,nx), np.linspace(0,1,ny)\r\n# xi, eta = np.meshgrid(xi_, eta_)\r\n# annulus = {some function with implemented boundary conditions}\r\n# x = TFI(xi, eta, annulus).X()\r\n# y = TFI(xi, eta, annulus).Y()\r\n#\r\n# :param xi: Xi is the computational space in the x axis\r\n# :param eta: Eta is the computational space in the y axis\r\n# :param annulus: Annulus is a function which computes the grid in physical plane wrt boundary conditions\r\n# :param Boundary: Boundary a boolean parameter to specify if TFI is used for generating boundary or satisfying\r\n# boundary conditions for computation\r\n# \"\"\"\r\n# self.xi = xi\r\n# self.eta = eta\r\n# self.annulus = annulus\r\n# self.dx = (xi.max() - xi.min()) / len(xi)\r\n# self.dy = (eta.max() - eta.min()) / len(eta)\r\n# self.bound = Boundary\r\n#\r\n# def __call__(self):\r\n# # get all the x related values\r\n# x = self.X()['x']\r\n# dxdxi = self.X()['dxdxi']\r\n# dxdeta = self.X()['dxdeta']\r\n#\r\n# # get all the y related values\r\n# y = self.Y()['y']\r\n# dydxi = self.Y()['dydxi']\r\n# dydeta = self.Y()['dydeta']\r\n#\r\n# # calculate the jacobian\r\n# jac = dxdxi*dydeta - dxdeta*dydxi\r\n#\r\n#\r\n#\r\n# return {'x':x, 'dxdxi': dxdxi, 'dxdeta':dxdeta, 'y':y, 'dydxi':dydxi, 'dydeta':dydeta}\r\n#\r\n# def X(self):\r\n# \"\"\"\r\n# X returns the interpolated x-axis values from xi and eta\r\n# :return: x axis values for physical plane in a dict format\r\n# \"\"\"\r\n# out = ((1 - self.eta) * self.annulus.Xr(self.xi) + self.eta * self.annulus.Xl(self.xi) + (1 - self.xi)\r\n# * self.annulus.Xt(self.eta) + self.xi * self.annulus.Xb(self.eta) -\r\n# (self.xi * self.eta * self.annulus.Xl(np.array([1])) + self.xi * (1 - self.eta) *\r\n# self.annulus.Xr(np.array([1])) + self.eta * (1 - self.xi) * self.annulus.Xl(np.array([0])) +\r\n# (1 - self.xi) * (1 - self.eta) * self.annulus.Xr(np.array([0]))))\r\n#\r\n#\r\n# dxdxi = np.gradient(out, self.dx)[0]\r\n# dxdeta = np.gradient(out, self.dx)[1]\r\n#\r\n# # testing np.gradient\r\n# #test_dx_dxi = np.gradient(out, self.xi)\r\n# #print(dxdxi)\r\n#\r\n# return {'x': out, 'dxdxi': dxdxi, 'dxdeta': dxdeta}\r\n# #return out\r\n#\r\n# def Y(self):\r\n# \"\"\"\r\n# Y returns the interpolated y-axis values from xi and eta\r\n# :return: Y axis values for physical plane in a dict format\r\n# \"\"\"\r\n# out = ((1 - self.eta) * self.annulus.Yr(self.xi) + self.eta * self.annulus.Yl(self.xi) + (1 - self.xi)\r\n# * self.annulus.Yt(self.eta) + self.xi * self.annulus.Yb(self.eta) -\r\n# (self.xi * self.eta * self.annulus.Yl(np.array([1])) + self.xi * (1 - self.eta) *\r\n# self.annulus.Yr(np.array([1])) + self.eta * (1 - self.xi) * self.annulus.Yl(np.array([0])) +\r\n# (1 - self.xi) * (1 - self.eta) * self.annulus.Yr(np.array([0]))))\r\n#\r\n# dydxi = np.gradient(out, self.dy)[0]\r\n# dydeta = np.gradient(out, self.dy)[1]\r\n#\r\n# return {'y': out, 'dydxi': dydxi, 'dydeta': dydeta}\r\n# #return out\r\n#\r\n# if __name__ == '__main__':\r\n# xi_ = np.linspace(0,1,40)\r\n# eta_ = np.linspace(0,1,40)\r\n# xi, eta = np.meshgrid(xi_, eta_)\r\n# anulus = Analytical_Annulus(1., 0.6, 0.)\r\n# grid = TFI(xi, eta, anulus)\r\n# print(grid())"
] |
[
[
"numpy.zeros",
"numpy.ones",
"numpy.abs",
"numpy.linspace",
"numpy.meshgrid"
]
] |
voodoohop/magenta
|
[
"23c9bc51038643c2c7365aac9abcca430e8cccc1"
] |
[
"magenta/music/sequences_lib.py"
] |
[
"# Copyright 2019 The Magenta Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Defines sequence of notes objects for creating datasets.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport collections\nimport copy\nimport itertools\nimport math\nimport operator\nimport random\n\nfrom magenta.music import chord_symbols_lib\nfrom magenta.music import constants\nfrom magenta.protobuf import music_pb2\nimport numpy as np\nfrom six.moves import range # pylint: disable=redefined-builtin\nimport tensorflow as tf\n\n# Set the quantization cutoff.\n# Note events before this cutoff are rounded down to nearest step. Notes\n# above this cutoff are rounded up to nearest step. The cutoff is given as a\n# fraction of a step.\n# For example, with quantize_cutoff = 0.75 using 0-based indexing,\n# if .75 < event <= 1.75, it will be quantized to step 1.\n# If 1.75 < event <= 2.75 it will be quantized to step 2.\n# A number close to 1.0 gives less wiggle room for notes that start early,\n# and they will be snapped to the previous step.\nQUANTIZE_CUTOFF = 0.5\n\n# Shortcut to text annotation types.\nBEAT = music_pb2.NoteSequence.TextAnnotation.BEAT\nCHORD_SYMBOL = music_pb2.NoteSequence.TextAnnotation.CHORD_SYMBOL\nUNKNOWN_PITCH_NAME = music_pb2.NoteSequence.UNKNOWN_PITCH_NAME\n\n# The amount to upweight note-on events vs note-off events.\nONSET_UPWEIGHT = 5.0\n\n# The size of the frame extension for onset event.\n# Frames in [onset_frame-ONSET_WINDOW, onset_frame+ONSET_WINDOW]\n# are considered to contain onset events.\nONSET_WINDOW = 1\n\n\nclass BadTimeSignatureError(Exception):\n pass\n\n\nclass MultipleTimeSignatureError(Exception):\n pass\n\n\nclass MultipleTempoError(Exception):\n pass\n\n\nclass NegativeTimeError(Exception):\n pass\n\n\nclass QuantizationStatusError(Exception):\n \"\"\"Exception for when a sequence was unexpectedly quantized or unquantized.\n\n Should not happen during normal operation and likely indicates a programming\n error.\n \"\"\"\n pass\n\n\nclass InvalidTimeAdjustmentError(Exception):\n pass\n\n\nclass RectifyBeatsError(Exception):\n pass\n\n\ndef trim_note_sequence(sequence, start_time, end_time):\n \"\"\"Trim notes from a NoteSequence to lie within a specified time range.\n\n Notes starting before `start_time` are not included. Notes ending after\n `end_time` are truncated.\n\n Args:\n sequence: The NoteSequence for which to trim notes.\n start_time: The float time in seconds after which all notes should begin.\n end_time: The float time in seconds before which all notes should end.\n\n Returns:\n A copy of `sequence` with all notes trimmed to lie between `start_time` and\n `end_time`.\n\n Raises:\n QuantizationStatusError: If the sequence has already been quantized.\n \"\"\"\n if is_quantized_sequence(sequence):\n raise QuantizationStatusError(\n 'Can only trim notes and chords for unquantized NoteSequence.')\n\n subsequence = music_pb2.NoteSequence()\n subsequence.CopyFrom(sequence)\n\n del subsequence.notes[:]\n for note in sequence.notes:\n if note.start_time < start_time or note.start_time >= end_time:\n continue\n new_note = subsequence.notes.add()\n new_note.CopyFrom(note)\n new_note.end_time = min(note.end_time, end_time)\n\n subsequence.total_time = min(sequence.total_time, end_time)\n\n return subsequence\n\n\nDEFAULT_SUBSEQUENCE_PRESERVE_CONTROL_NUMBERS = (\n 64, # sustain\n 66, # sostenuto\n 67, # una corda\n)\n\n\ndef _extract_subsequences(sequence, split_times,\n preserve_control_numbers=None):\n \"\"\"Extracts multiple subsequences from a NoteSequence.\n\n Args:\n sequence: The NoteSequence to extract subsequences from.\n split_times: A Python list of subsequence boundary times. The first\n subsequence will start at `split_times[0]` and end at `split_times[1]`,\n the next subsequence will start at `split_times[1]` and end at\n `split_times[2]`, and so on with the last subsequence ending at\n `split_times[-1]`.\n preserve_control_numbers: List of control change numbers to preserve as\n pedal events. The most recent event before the beginning of the\n subsequence will be inserted at the beginning of the subsequence.\n If None, will use DEFAULT_SUBSEQUENCE_PRESERVE_CONTROL_NUMBERS.\n\n Returns:\n A Python list of new NoteSequence containing the subsequences of `sequence`.\n\n Raises:\n QuantizationStatusError: If the sequence has already been quantized.\n ValueError: If there are fewer than 2 split times, or the split times are\n unsorted, or if any of the subsequences would start past the end of the\n sequence.\n \"\"\"\n if is_quantized_sequence(sequence):\n raise QuantizationStatusError(\n 'Can only extract subsequences from unquantized NoteSequence.')\n\n if len(split_times) < 2:\n raise ValueError('Must provide at least a start and end time.')\n if any(t1 > t2 for t1, t2 in zip(split_times[:-1], split_times[1:])):\n raise ValueError('Split times must be sorted.')\n if any(time >= sequence.total_time for time in split_times[:-1]):\n raise ValueError('Cannot extract subsequence past end of sequence.')\n\n if preserve_control_numbers is None:\n preserve_control_numbers = DEFAULT_SUBSEQUENCE_PRESERVE_CONTROL_NUMBERS\n\n subsequence = music_pb2.NoteSequence()\n subsequence.CopyFrom(sequence)\n\n subsequence.total_time = 0.0\n\n del subsequence.notes[:]\n del subsequence.time_signatures[:]\n del subsequence.key_signatures[:]\n del subsequence.tempos[:]\n del subsequence.text_annotations[:]\n del subsequence.control_changes[:]\n del subsequence.pitch_bends[:]\n\n subsequences = [\n copy.deepcopy(subsequence) for _ in range(len(split_times) - 1)\n ]\n\n # Extract notes into subsequences.\n subsequence_index = -1\n for note in sorted(sequence.notes, key=lambda note: note.start_time):\n if note.start_time < split_times[0]:\n continue\n while (subsequence_index < len(split_times) - 1 and\n note.start_time >= split_times[subsequence_index + 1]):\n subsequence_index += 1\n if subsequence_index == len(split_times) - 1:\n break\n subsequences[subsequence_index].notes.extend([note])\n subsequences[subsequence_index].notes[-1].start_time -= (\n split_times[subsequence_index])\n subsequences[subsequence_index].notes[-1].end_time = min(\n note.end_time,\n split_times[subsequence_index + 1]) - split_times[subsequence_index]\n if (subsequences[subsequence_index].notes[-1].end_time >\n subsequences[subsequence_index].total_time):\n subsequences[subsequence_index].total_time = (\n subsequences[subsequence_index].notes[-1].end_time)\n\n # Extract time signatures, key signatures, tempos, and chord changes (beats\n # are handled below, other text annotations and pitch bends are deleted).\n # Additional state events will be added to the beginning of each subsequence.\n\n events_by_type = [\n sequence.time_signatures, sequence.key_signatures, sequence.tempos,\n [\n annotation for annotation in sequence.text_annotations\n if annotation.annotation_type == CHORD_SYMBOL\n ]\n ]\n new_event_containers = [[s.time_signatures for s in subsequences],\n [s.key_signatures for s in subsequences],\n [s.tempos for s in subsequences],\n [s.text_annotations for s in subsequences]]\n\n for events, containers in zip(events_by_type, new_event_containers):\n previous_event = None\n subsequence_index = -1\n for event in sorted(events, key=lambda event: event.time):\n if event.time <= split_times[0]:\n previous_event = event\n continue\n while (subsequence_index < len(split_times) - 1 and\n event.time > split_times[subsequence_index + 1]):\n subsequence_index += 1\n if subsequence_index == len(split_times) - 1:\n break\n if previous_event is not None:\n # Add state event to the beginning of the subsequence.\n containers[subsequence_index].extend([previous_event])\n containers[subsequence_index][-1].time = 0.0\n if subsequence_index == len(split_times) - 1:\n break\n # Only add the event if it's actually inside the subsequence (and not on\n # the boundary with the next one).\n if event.time < split_times[subsequence_index + 1]:\n containers[subsequence_index].extend([event])\n containers[subsequence_index][-1].time -= split_times[subsequence_index]\n previous_event = event\n # Add final state event to the beginning of all remaining subsequences.\n while subsequence_index < len(split_times) - 2:\n subsequence_index += 1\n if previous_event is not None:\n containers[subsequence_index].extend([previous_event])\n containers[subsequence_index][-1].time = 0.0\n\n # Copy stateless events to subsequences. Unlike the stateful events above,\n # stateless events do not have an effect outside of the subsequence in which\n # they occur.\n stateless_events_by_type = [[\n annotation for annotation in sequence.text_annotations\n if annotation.annotation_type in (BEAT,)\n ]]\n new_stateless_event_containers = [[s.text_annotations for s in subsequences]]\n for events, containers in zip(stateless_events_by_type,\n new_stateless_event_containers):\n subsequence_index = -1\n for event in sorted(events, key=lambda event: event.time):\n if event.time < split_times[0]:\n continue\n while (subsequence_index < len(split_times) - 1 and\n event.time >= split_times[subsequence_index + 1]):\n subsequence_index += 1\n if subsequence_index == len(split_times) - 1:\n break\n containers[subsequence_index].extend([event])\n containers[subsequence_index][-1].time -= split_times[subsequence_index]\n\n # Extract piano pedal events (other control changes are deleted). Pedal state\n # is maintained per-instrument and added to the beginning of each\n # subsequence.\n pedal_events = [\n cc for cc in sequence.control_changes\n if cc.control_number in preserve_control_numbers\n ]\n previous_pedal_events = {}\n subsequence_index = -1\n for pedal_event in sorted(pedal_events, key=lambda event: event.time):\n if pedal_event.time <= split_times[0]:\n previous_pedal_events[\n (pedal_event.instrument, pedal_event.control_number)] = pedal_event\n continue\n while (subsequence_index < len(split_times) - 1 and\n pedal_event.time > split_times[subsequence_index + 1]):\n subsequence_index += 1\n if subsequence_index == len(split_times) - 1:\n break\n # Add the current pedal pedal state to the beginning of the subsequence.\n for previous_pedal_event in previous_pedal_events.values():\n subsequences[subsequence_index].control_changes.extend(\n [previous_pedal_event])\n subsequences[subsequence_index].control_changes[-1].time = 0.0\n if subsequence_index == len(split_times) - 1:\n break\n # Only add the pedal event if it's actually inside the subsequence (and\n # not on the boundary with the next one).\n if pedal_event.time < split_times[subsequence_index + 1]:\n subsequences[subsequence_index].control_changes.extend([pedal_event])\n subsequences[subsequence_index].control_changes[-1].time -= (\n split_times[subsequence_index])\n previous_pedal_events[\n (pedal_event.instrument, pedal_event.control_number)] = pedal_event\n # Add final pedal pedal state to the beginning of all remaining\n # subsequences.\n while subsequence_index < len(split_times) - 2:\n subsequence_index += 1\n for previous_pedal_event in previous_pedal_events.values():\n subsequences[subsequence_index].control_changes.extend(\n [previous_pedal_event])\n subsequences[subsequence_index].control_changes[-1].time = 0.0\n\n # Set subsequence info for all subsequences.\n for subsequence, start_time in zip(subsequences, split_times[:-1]):\n subsequence.subsequence_info.start_time_offset = start_time\n subsequence.subsequence_info.end_time_offset = (\n sequence.total_time - start_time - subsequence.total_time)\n\n return subsequences\n\n\ndef extract_subsequence(sequence,\n start_time,\n end_time,\n preserve_control_numbers=None):\n \"\"\"Extracts a subsequence from a NoteSequence.\n\n Notes starting before `start_time` are not included. Notes ending after\n `end_time` are truncated. Time signature, tempo, key signature, chord changes,\n and sustain pedal events outside the specified time range are removed;\n however, the most recent event of each of these types prior to `start_time` is\n included at `start_time`. This means that e.g. if a time signature of 3/4 is\n specified in the original sequence prior to `start_time` (and is not followed\n by a different time signature), the extracted subsequence will include a 3/4\n time signature event at `start_time`. Pitch bends and control changes other\n than sustain are removed entirely.\n\n The extracted subsequence is shifted to start at time zero.\n\n Args:\n sequence: The NoteSequence to extract a subsequence from.\n start_time: The float time in seconds to start the subsequence.\n end_time: The float time in seconds to end the subsequence.\n preserve_control_numbers: List of control change numbers to preserve as\n pedal events. The most recent event before the beginning of the\n subsequence will be inserted at the beginning of the subsequence.\n If None, will use DEFAULT_SUBSEQUENCE_PRESERVE_CONTROL_NUMBERS.\n\n\n Returns:\n A new NoteSequence containing the subsequence of `sequence` from the\n specified time range.\n\n Raises:\n QuantizationStatusError: If the sequence has already been quantized.\n ValueError: If `start_time` is past the end of `sequence`.\n \"\"\"\n return _extract_subsequences(\n sequence,\n split_times=[start_time, end_time],\n preserve_control_numbers=preserve_control_numbers)[0]\n\n\ndef shift_sequence_times(sequence, shift_seconds):\n \"\"\"Shifts times in a notesequence.\n\n Only forward shifts are supported.\n\n Args:\n sequence: The NoteSequence to shift.\n shift_seconds: The amount to shift.\n\n Returns:\n A new NoteSequence with shifted times.\n\n Raises:\n ValueError: If the shift amount is invalid.\n QuantizationStatusError: If the sequence has already been quantized.\n \"\"\"\n if shift_seconds <= 0:\n raise ValueError('Invalid shift amount: {}'.format(shift_seconds))\n if is_quantized_sequence(sequence):\n raise QuantizationStatusError(\n 'Can shift only unquantized NoteSequences.')\n\n shifted = music_pb2.NoteSequence()\n shifted.CopyFrom(sequence)\n\n # Delete subsequence_info because our frame of reference has shifted.\n shifted.ClearField('subsequence_info')\n\n # Shift notes.\n for note in shifted.notes:\n note.start_time += shift_seconds\n note.end_time += shift_seconds\n\n events_to_shift = [\n shifted.time_signatures, shifted.key_signatures, shifted.tempos,\n shifted.pitch_bends, shifted.control_changes, shifted.text_annotations,\n shifted.section_annotations\n ]\n\n for event in itertools.chain(*events_to_shift):\n event.time += shift_seconds\n\n shifted.total_time += shift_seconds\n\n return shifted\n\n\ndef remove_redundant_data(sequence):\n \"\"\"Returns a copy of the sequence with redundant data removed.\n\n An event is considered redundant if it is a time signature, a key signature,\n or a tempo that differs from the previous event of the same type only by time.\n For example, a tempo mark of 120 qpm at 5 seconds would be considered\n redundant if it followed a tempo mark of 120 qpm and 4 seconds.\n\n Fields in sequence_metadata are considered redundant if the same string is\n repeated.\n\n Args:\n sequence: The sequence to process.\n\n Returns:\n A new sequence with redundant events removed.\n \"\"\"\n fixed_sequence = copy.deepcopy(sequence)\n for events in [\n fixed_sequence.time_signatures, fixed_sequence.key_signatures,\n fixed_sequence.tempos\n ]:\n events.sort(key=lambda e: e.time)\n for i in range(len(events) - 1, 0, -1):\n tmp_ts = copy.deepcopy(events[i])\n tmp_ts.time = events[i - 1].time\n # If the only difference between the two events is time, then delete the\n # second one.\n if tmp_ts == events[i - 1]:\n del events[i]\n\n if fixed_sequence.HasField('sequence_metadata'):\n # Add composers and genres, preserving order, but dropping duplicates.\n del fixed_sequence.sequence_metadata.composers[:]\n added_composer = set()\n for composer in sequence.sequence_metadata.composers:\n if composer not in added_composer:\n fixed_sequence.sequence_metadata.composers.append(composer)\n added_composer.add(composer)\n\n del fixed_sequence.sequence_metadata.genre[:]\n added_genre = set()\n for genre in sequence.sequence_metadata.genre:\n if genre not in added_genre:\n fixed_sequence.sequence_metadata.genre.append(genre)\n added_genre.add(genre)\n\n return fixed_sequence\n\n\ndef concatenate_sequences(sequences, sequence_durations=None):\n \"\"\"Concatenate a series of NoteSequences together.\n\n Individual sequences will be shifted using shift_sequence_times and then\n merged together using the protobuf MergeFrom method. This means that any\n global values (e.g., ticks_per_quarter) will be overwritten by each sequence\n and only the final value will be used. After this, redundant data will be\n removed with remove_redundant_data.\n\n Args:\n sequences: A list of sequences to concatenate.\n sequence_durations: An optional list of sequence durations to use. If not\n specified, the total_time value will be used. Specifying durations is\n useful if the sequences to be concatenated are effectively longer than\n their total_time (e.g., a sequence that ends with a rest).\n\n Returns:\n A new sequence that is the result of concatenating *sequences.\n\n Raises:\n ValueError: If the length of sequences and sequence_durations do not match\n or if a specified duration is less than the total_time of the sequence.\n \"\"\"\n if sequence_durations and len(sequences) != len(sequence_durations):\n raise ValueError(\n 'sequences and sequence_durations must be the same length.')\n current_total_time = 0\n cat_seq = music_pb2.NoteSequence()\n for i in range(len(sequences)):\n sequence = sequences[i]\n if sequence_durations and sequence_durations[i] < sequence.total_time:\n raise ValueError(\n 'Specified sequence duration ({}) must not be less than the '\n 'total_time of the sequence ({})'.format(sequence_durations[i],\n sequence.total_time))\n if current_total_time > 0:\n cat_seq.MergeFrom(shift_sequence_times(sequence, current_total_time))\n else:\n cat_seq.MergeFrom(sequence)\n\n if sequence_durations:\n current_total_time += sequence_durations[i]\n else:\n current_total_time = cat_seq.total_time\n\n # Delete subsequence_info because we've joined several subsequences.\n cat_seq.ClearField('subsequence_info')\n\n return remove_redundant_data(cat_seq)\n\n\ndef repeat_sequence_to_duration(sequence, duration, sequence_duration=None):\n \"\"\"Repeat a sequence until it is a given duration, trimming any extra.\n\n Args:\n sequence: the sequence to repeat\n duration: the desired duration\n sequence_duration: If provided, will be used instead of sequence.total_time\n\n Returns:\n The repeated and possibly trimmed sequence.\n \"\"\"\n if not sequence_duration:\n sequence_duration = sequence.total_time\n num_repeats = int(math.ceil(duration / sequence_duration))\n repeated_ns = concatenate_sequences(\n [sequence] * num_repeats,\n sequence_durations=[sequence_duration] * num_repeats)\n\n trimmed = extract_subsequence(repeated_ns, start_time=0, end_time=duration)\n trimmed.ClearField('subsequence_info') # Not relevant in this case.\n return trimmed\n\n\ndef expand_section_groups(sequence):\n \"\"\"Expands a NoteSequence based on its section_groups.\n\n Args:\n sequence: The sequence to expand.\n\n Returns:\n A copy of the original sequence, expanded based on its section_groups. If\n the sequence has no section_groups, a copy of the original sequence will be\n returned.\n \"\"\"\n if not sequence.section_groups:\n return copy.deepcopy(sequence)\n\n sections = {}\n section_durations = {}\n for i in range(len(sequence.section_annotations)):\n section_id = sequence.section_annotations[i].section_id\n start_time = sequence.section_annotations[i].time\n if i < len(sequence.section_annotations) - 1:\n end_time = sequence.section_annotations[i + 1].time\n else:\n end_time = sequence.total_time\n\n subsequence = extract_subsequence(sequence, start_time, end_time)\n # This is a subsequence, so the section_groups no longer make sense.\n del subsequence.section_groups[:]\n # This subsequence contains only 1 section and it has been shifted to time\n # 0.\n del subsequence.section_annotations[:]\n subsequence.section_annotations.add(time=0, section_id=section_id)\n\n sections[section_id] = subsequence\n section_durations[section_id] = end_time - start_time\n\n # Recursively expand section_groups.\n def sections_in_group(section_group):\n sections = []\n for section in section_group.sections:\n field = section.WhichOneof('section_type')\n if field == 'section_id':\n sections.append(section.section_id)\n elif field == 'section_group':\n sections.extend(sections_in_group(section.section_group))\n return sections * section_group.num_times\n\n sections_to_concat = []\n for section_group in sequence.section_groups:\n sections_to_concat.extend(sections_in_group(section_group))\n\n return concatenate_sequences(\n [sections[i] for i in sections_to_concat],\n [section_durations[i] for i in sections_to_concat])\n\n\ndef _is_power_of_2(x):\n return x and not x & (x - 1)\n\n\ndef is_quantized_sequence(note_sequence):\n \"\"\"Returns whether or not a NoteSequence proto has been quantized.\n\n Args:\n note_sequence: A music_pb2.NoteSequence proto.\n\n Returns:\n True if `note_sequence` is quantized, otherwise False.\n \"\"\"\n # If the QuantizationInfo message has a non-zero steps_per_quarter or\n # steps_per_second, assume that the proto has been quantized.\n return (note_sequence.quantization_info.steps_per_quarter > 0 or\n note_sequence.quantization_info.steps_per_second > 0)\n\n\ndef is_relative_quantized_sequence(note_sequence):\n \"\"\"Returns whether a NoteSequence proto has been quantized relative to tempo.\n\n Args:\n note_sequence: A music_pb2.NoteSequence proto.\n\n Returns:\n True if `note_sequence` is quantized relative to tempo, otherwise False.\n \"\"\"\n # If the QuantizationInfo message has a non-zero steps_per_quarter, assume\n # that the proto has been quantized relative to tempo.\n return note_sequence.quantization_info.steps_per_quarter > 0\n\n\ndef is_absolute_quantized_sequence(note_sequence):\n \"\"\"Returns whether a NoteSequence proto has been quantized by absolute time.\n\n Args:\n note_sequence: A music_pb2.NoteSequence proto.\n\n Returns:\n True if `note_sequence` is quantized by absolute time, otherwise False.\n \"\"\"\n # If the QuantizationInfo message has a non-zero steps_per_second, assume\n # that the proto has been quantized by absolute time.\n return note_sequence.quantization_info.steps_per_second > 0\n\n\ndef assert_is_quantized_sequence(note_sequence):\n \"\"\"Confirms that the given NoteSequence proto has been quantized.\n\n Args:\n note_sequence: A music_pb2.NoteSequence proto.\n\n Raises:\n QuantizationStatusError: If the sequence is not quantized.\n \"\"\"\n if not is_quantized_sequence(note_sequence):\n raise QuantizationStatusError(\n 'NoteSequence %s is not quantized.' % note_sequence.id)\n\n\ndef assert_is_relative_quantized_sequence(note_sequence):\n \"\"\"Confirms that a NoteSequence proto has been quantized relative to tempo.\n\n Args:\n note_sequence: A music_pb2.NoteSequence proto.\n\n Raises:\n QuantizationStatusError: If the sequence is not quantized relative to\n tempo.\n \"\"\"\n if not is_relative_quantized_sequence(note_sequence):\n raise QuantizationStatusError(\n 'NoteSequence %s is not quantized or is '\n 'quantized based on absolute timing.' % note_sequence.id)\n\n\ndef assert_is_absolute_quantized_sequence(note_sequence):\n \"\"\"Confirms that a NoteSequence proto has been quantized by absolute time.\n\n Args:\n note_sequence: A music_pb2.NoteSequence proto.\n\n Raises:\n QuantizationStatusError: If the sequence is not quantized by absolute\n time.\n \"\"\"\n if not is_absolute_quantized_sequence(note_sequence):\n raise QuantizationStatusError(\n 'NoteSequence %s is not quantized or is '\n 'quantized based on relative timing.' % note_sequence.id)\n\n\ndef steps_per_bar_in_quantized_sequence(note_sequence):\n \"\"\"Calculates steps per bar in a NoteSequence that has been quantized.\n\n Args:\n note_sequence: The NoteSequence to examine.\n\n Returns:\n Steps per bar as a floating point number.\n \"\"\"\n assert_is_relative_quantized_sequence(note_sequence)\n\n quarters_per_beat = 4.0 / note_sequence.time_signatures[0].denominator\n quarters_per_bar = (\n quarters_per_beat * note_sequence.time_signatures[0].numerator)\n steps_per_bar_float = (\n note_sequence.quantization_info.steps_per_quarter * quarters_per_bar)\n return steps_per_bar_float\n\n\ndef split_note_sequence(note_sequence,\n hop_size_seconds,\n skip_splits_inside_notes=False):\n \"\"\"Split one NoteSequence into many at specified time intervals.\n\n If `hop_size_seconds` is a scalar, this function splits a NoteSequence into\n multiple NoteSequences, all of fixed size (unless `split_notes` is False, in\n which case splits that would have truncated notes will be skipped; i.e. each\n split will either happen at a multiple of `hop_size_seconds` or not at all).\n Each of the resulting NoteSequences is shifted to start at time zero.\n\n If `hop_size_seconds` is a list, the NoteSequence will be split at each time\n in the list (unless `split_notes` is False as above).\n\n Args:\n note_sequence: The NoteSequence to split.\n hop_size_seconds: The hop size, in seconds, at which the NoteSequence will\n be split. Alternatively, this can be a Python list of times in seconds at\n which to split the NoteSequence.\n skip_splits_inside_notes: If False, the NoteSequence will be split at all\n hop positions, regardless of whether or not any notes are sustained across\n the potential split time, thus sustained notes will be truncated. If True,\n the NoteSequence will not be split at positions that occur within\n sustained notes.\n\n Returns:\n A Python list of NoteSequences.\n \"\"\"\n notes_by_start_time = sorted(\n list(note_sequence.notes), key=lambda note: note.start_time)\n note_idx = 0\n notes_crossing_split = []\n\n if isinstance(hop_size_seconds, list):\n split_times = sorted(hop_size_seconds)\n else:\n split_times = np.arange(hop_size_seconds, note_sequence.total_time,\n hop_size_seconds)\n\n valid_split_times = [0.0]\n\n for split_time in split_times:\n # Update notes crossing potential split.\n while (note_idx < len(notes_by_start_time) and\n notes_by_start_time[note_idx].start_time < split_time):\n notes_crossing_split.append(notes_by_start_time[note_idx])\n note_idx += 1\n notes_crossing_split = [\n note for note in notes_crossing_split if note.end_time > split_time\n ]\n\n if not (skip_splits_inside_notes and notes_crossing_split):\n valid_split_times.append(split_time)\n\n # Handle the final subsequence.\n if note_sequence.total_time > valid_split_times[-1]:\n valid_split_times.append(note_sequence.total_time)\n\n if len(valid_split_times) > 1:\n return _extract_subsequences(note_sequence, valid_split_times)\n else:\n return []\n\n\ndef split_note_sequence_on_time_changes(note_sequence,\n skip_splits_inside_notes=False):\n \"\"\"Split one NoteSequence into many around time signature and tempo changes.\n\n This function splits a NoteSequence into multiple NoteSequences, each of which\n contains only a single time signature and tempo, unless `split_notes` is False\n in which case all time signature and tempo changes occur within sustained\n notes. Each of the resulting NoteSequences is shifted to start at time zero.\n\n Args:\n note_sequence: The NoteSequence to split.\n skip_splits_inside_notes: If False, the NoteSequence will be split at all\n time changes, regardless of whether or not any notes are sustained across\n the time change. If True, the NoteSequence will not be split at time\n changes that occur within sustained notes.\n\n Returns:\n A Python list of NoteSequences.\n \"\"\"\n current_numerator = 4\n current_denominator = 4\n current_qpm = constants.DEFAULT_QUARTERS_PER_MINUTE\n\n time_signatures_and_tempos = sorted(\n list(note_sequence.time_signatures) + list(note_sequence.tempos),\n key=lambda t: t.time)\n time_signatures_and_tempos = [\n t for t in time_signatures_and_tempos if t.time < note_sequence.total_time\n ]\n\n notes_by_start_time = sorted(\n list(note_sequence.notes), key=lambda note: note.start_time)\n note_idx = 0\n notes_crossing_split = []\n\n valid_split_times = [0.0]\n\n for time_change in time_signatures_and_tempos:\n if isinstance(time_change, music_pb2.NoteSequence.TimeSignature):\n if (time_change.numerator == current_numerator and\n time_change.denominator == current_denominator):\n # Time signature didn't actually change.\n continue\n else:\n if time_change.qpm == current_qpm:\n # Tempo didn't actually change.\n continue\n\n # Update notes crossing potential split.\n while (note_idx < len(notes_by_start_time) and\n notes_by_start_time[note_idx].start_time < time_change.time):\n notes_crossing_split.append(notes_by_start_time[note_idx])\n note_idx += 1\n notes_crossing_split = [\n note for note in notes_crossing_split\n if note.end_time > time_change.time\n ]\n\n if time_change.time > valid_split_times[-1]:\n if not (skip_splits_inside_notes and notes_crossing_split):\n valid_split_times.append(time_change.time)\n\n # Even if we didn't split here, update the current time signature or tempo.\n if isinstance(time_change, music_pb2.NoteSequence.TimeSignature):\n current_numerator = time_change.numerator\n current_denominator = time_change.denominator\n else:\n current_qpm = time_change.qpm\n\n # Handle the final subsequence.\n if note_sequence.total_time > valid_split_times[-1]:\n valid_split_times.append(note_sequence.total_time)\n\n if len(valid_split_times) > 1:\n return _extract_subsequences(note_sequence, valid_split_times)\n else:\n return []\n\n\ndef quantize_to_step(unquantized_seconds,\n steps_per_second,\n quantize_cutoff=QUANTIZE_CUTOFF):\n \"\"\"Quantizes seconds to the nearest step, given steps_per_second.\n\n See the comments above `QUANTIZE_CUTOFF` for details on how the quantizing\n algorithm works.\n\n Args:\n unquantized_seconds: Seconds to quantize.\n steps_per_second: Quantizing resolution.\n quantize_cutoff: Value to use for quantizing cutoff.\n\n Returns:\n The input value quantized to the nearest step.\n \"\"\"\n unquantized_steps = unquantized_seconds * steps_per_second\n return int(unquantized_steps + (1 - quantize_cutoff))\n\n\ndef steps_per_quarter_to_steps_per_second(steps_per_quarter, qpm):\n \"\"\"Calculates steps per second given steps_per_quarter and a qpm.\"\"\"\n return steps_per_quarter * qpm / 60.0\n\n\ndef _quantize_notes(note_sequence, steps_per_second):\n \"\"\"Quantize the notes and chords of a NoteSequence proto in place.\n\n Note start and end times, and chord times are snapped to a nearby quantized\n step, and the resulting times are stored in a separate field (e.g.,\n quantized_start_step). See the comments above `QUANTIZE_CUTOFF` for details on\n how the quantizing algorithm works.\n\n Args:\n note_sequence: A music_pb2.NoteSequence protocol buffer. Will be modified in\n place.\n steps_per_second: Each second will be divided into this many quantized time\n steps.\n\n Raises:\n NegativeTimeError: If a note or chord occurs at a negative time.\n \"\"\"\n for note in note_sequence.notes:\n # Quantize the start and end times of the note.\n note.quantized_start_step = quantize_to_step(note.start_time,\n steps_per_second)\n note.quantized_end_step = quantize_to_step(note.end_time, steps_per_second)\n if note.quantized_end_step == note.quantized_start_step:\n note.quantized_end_step += 1\n\n # Do not allow notes to start or end in negative time.\n if note.quantized_start_step < 0 or note.quantized_end_step < 0:\n raise NegativeTimeError(\n 'Got negative note time: start_step = %s, end_step = %s' %\n (note.quantized_start_step, note.quantized_end_step))\n\n # Extend quantized sequence if necessary.\n if note.quantized_end_step > note_sequence.total_quantized_steps:\n note_sequence.total_quantized_steps = note.quantized_end_step\n\n # Also quantize control changes and text annotations.\n for event in itertools.chain(note_sequence.control_changes,\n note_sequence.text_annotations):\n # Quantize the event time, disallowing negative time.\n event.quantized_step = quantize_to_step(event.time, steps_per_second)\n if event.quantized_step < 0:\n raise NegativeTimeError(\n 'Got negative event time: step = %s' % event.quantized_step)\n\n\ndef quantize_note_sequence(note_sequence, steps_per_quarter):\n \"\"\"Quantize a NoteSequence proto relative to tempo.\n\n The input NoteSequence is copied and quantization-related fields are\n populated. Sets the `steps_per_quarter` field in the `quantization_info`\n message in the NoteSequence.\n\n Note start and end times, and chord times are snapped to a nearby quantized\n step, and the resulting times are stored in a separate field (e.g.,\n quantized_start_step). See the comments above `QUANTIZE_CUTOFF` for details on\n how the quantizing algorithm works.\n\n Args:\n note_sequence: A music_pb2.NoteSequence protocol buffer.\n steps_per_quarter: Each quarter note of music will be divided into this many\n quantized time steps.\n\n Returns:\n A copy of the original NoteSequence, with quantized times added.\n\n Raises:\n MultipleTimeSignatureError: If there is a change in time signature\n in `note_sequence`.\n MultipleTempoError: If there is a change in tempo in `note_sequence`.\n BadTimeSignatureError: If the time signature found in `note_sequence`\n has a 0 numerator or a denominator which is not a power of 2.\n NegativeTimeError: If a note or chord occurs at a negative time.\n \"\"\"\n qns = copy.deepcopy(note_sequence)\n\n qns.quantization_info.steps_per_quarter = steps_per_quarter\n\n if qns.time_signatures:\n time_signatures = sorted(qns.time_signatures, key=lambda ts: ts.time)\n # There is an implicit 4/4 time signature at 0 time. So if the first time\n # signature is something other than 4/4 and it's at a time other than 0,\n # that's an implicit time signature change.\n if time_signatures[0].time != 0 and not (\n time_signatures[0].numerator == 4 and\n time_signatures[0].denominator == 4):\n raise MultipleTimeSignatureError(\n 'NoteSequence has an implicit change from initial 4/4 time '\n 'signature to %d/%d at %.2f seconds.' %\n (time_signatures[0].numerator, time_signatures[0].denominator,\n time_signatures[0].time))\n\n for time_signature in time_signatures[1:]:\n if (time_signature.numerator != qns.time_signatures[0].numerator or\n time_signature.denominator != qns.time_signatures[0].denominator):\n raise MultipleTimeSignatureError(\n 'NoteSequence has at least one time signature change from %d/%d to '\n '%d/%d at %.2f seconds.' %\n (time_signatures[0].numerator, time_signatures[0].denominator,\n time_signature.numerator, time_signature.denominator,\n time_signature.time))\n\n # Make it clear that there is only 1 time signature and it starts at the\n # beginning.\n qns.time_signatures[0].time = 0\n del qns.time_signatures[1:]\n else:\n time_signature = qns.time_signatures.add()\n time_signature.numerator = 4\n time_signature.denominator = 4\n time_signature.time = 0\n\n if not _is_power_of_2(qns.time_signatures[0].denominator):\n raise BadTimeSignatureError(\n 'Denominator is not a power of 2. Time signature: %d/%d' %\n (qns.time_signatures[0].numerator, qns.time_signatures[0].denominator))\n\n if qns.time_signatures[0].numerator == 0:\n raise BadTimeSignatureError(\n 'Numerator is 0. Time signature: %d/%d' %\n (qns.time_signatures[0].numerator, qns.time_signatures[0].denominator))\n\n if qns.tempos:\n tempos = sorted(qns.tempos, key=lambda t: t.time)\n # There is an implicit 120.0 qpm tempo at 0 time. So if the first tempo is\n # something other that 120.0 and it's at a time other than 0, that's an\n # implicit tempo change.\n if tempos[0].time != 0 and (tempos[0].qpm !=\n constants.DEFAULT_QUARTERS_PER_MINUTE):\n raise MultipleTempoError(\n 'NoteSequence has an implicit tempo change from initial %.1f qpm to '\n '%.1f qpm at %.2f seconds.' % (constants.DEFAULT_QUARTERS_PER_MINUTE,\n tempos[0].qpm, tempos[0].time))\n\n for tempo in tempos[1:]:\n if tempo.qpm != qns.tempos[0].qpm:\n raise MultipleTempoError(\n 'NoteSequence has at least one tempo change from %.1f qpm to %.1f '\n 'qpm at %.2f seconds.' % (tempos[0].qpm, tempo.qpm, tempo.time))\n\n # Make it clear that there is only 1 tempo and it starts at the beginning.\n qns.tempos[0].time = 0\n del qns.tempos[1:]\n else:\n tempo = qns.tempos.add()\n tempo.qpm = constants.DEFAULT_QUARTERS_PER_MINUTE\n tempo.time = 0\n\n # Compute quantization steps per second.\n steps_per_second = steps_per_quarter_to_steps_per_second(\n steps_per_quarter, qns.tempos[0].qpm)\n\n qns.total_quantized_steps = quantize_to_step(qns.total_time, steps_per_second)\n _quantize_notes(qns, steps_per_second)\n\n return qns\n\n\ndef quantize_note_sequence_absolute(note_sequence, steps_per_second):\n \"\"\"Quantize a NoteSequence proto using absolute event times.\n\n The input NoteSequence is copied and quantization-related fields are\n populated. Sets the `steps_per_second` field in the `quantization_info`\n message in the NoteSequence.\n\n Note start and end times, and chord times are snapped to a nearby quantized\n step, and the resulting times are stored in a separate field (e.g.,\n quantized_start_step). See the comments above `QUANTIZE_CUTOFF` for details on\n how the quantizing algorithm works.\n\n Tempos and time signatures will be copied but ignored.\n\n Args:\n note_sequence: A music_pb2.NoteSequence protocol buffer.\n steps_per_second: Each second will be divided into this many quantized time\n steps.\n\n Returns:\n A copy of the original NoteSequence, with quantized times added.\n\n Raises:\n NegativeTimeError: If a note or chord occurs at a negative time.\n \"\"\"\n qns = copy.deepcopy(note_sequence)\n qns.quantization_info.steps_per_second = steps_per_second\n\n qns.total_quantized_steps = quantize_to_step(qns.total_time, steps_per_second)\n _quantize_notes(qns, steps_per_second)\n\n return qns\n\n\ndef transpose_note_sequence(ns,\n amount,\n min_allowed_pitch=constants.MIN_MIDI_PITCH,\n max_allowed_pitch=constants.MAX_MIDI_PITCH,\n transpose_chords=True,\n in_place=False):\n \"\"\"Transposes note sequence specified amount, deleting out-of-bound notes.\n\n Args:\n ns: The NoteSequence proto to be transposed.\n amount: Number of half-steps to transpose up or down.\n min_allowed_pitch: Minimum pitch allowed in transposed NoteSequence. Notes\n assigned lower pitches will be deleted.\n max_allowed_pitch: Maximum pitch allowed in transposed NoteSequence. Notes\n assigned higher pitches will be deleted.\n transpose_chords: If True, also transpose chord symbol text annotations. If\n False, chord symbols will be removed.\n in_place: If True, the input note_sequence is edited directly.\n\n Returns:\n The transposed NoteSequence and a count of how many notes were deleted.\n\n Raises:\n ChordSymbolError: If a chord symbol is unable to be transposed.\n \"\"\"\n if not in_place:\n new_ns = music_pb2.NoteSequence()\n new_ns.CopyFrom(ns)\n ns = new_ns\n\n new_note_list = []\n deleted_note_count = 0\n end_time = 0\n\n for note in ns.notes:\n new_pitch = note.pitch + amount\n if (min_allowed_pitch <= new_pitch <= max_allowed_pitch) or note.is_drum:\n end_time = max(end_time, note.end_time)\n\n if not note.is_drum:\n note.pitch += amount\n\n # The pitch name, if present, will no longer be valid.\n note.pitch_name = UNKNOWN_PITCH_NAME\n\n new_note_list.append(note)\n else:\n deleted_note_count += 1\n\n if deleted_note_count > 0:\n del ns.notes[:]\n ns.notes.extend(new_note_list)\n\n # Since notes were deleted, we may need to update the total time.\n ns.total_time = end_time\n\n if transpose_chords:\n # Also update the chord symbol text annotations. This can raise a\n # ChordSymbolError if a chord symbol cannot be interpreted.\n for ta in ns.text_annotations:\n if ta.annotation_type == CHORD_SYMBOL and ta.text != constants.NO_CHORD:\n ta.text = chord_symbols_lib.transpose_chord_symbol(ta.text, amount)\n else:\n # Remove chord symbol text annotations.\n text_annotations_to_keep = []\n for ta in ns.text_annotations:\n if ta.annotation_type != CHORD_SYMBOL:\n text_annotations_to_keep.append(ta)\n if len(text_annotations_to_keep) < len(ns.text_annotations):\n del ns.text_annotations[:]\n ns.text_annotations.extend(text_annotations_to_keep)\n\n # Also transpose key signatures.\n for ks in ns.key_signatures:\n ks.key = (ks.key + amount) % 12\n\n return ns, deleted_note_count\n\n\ndef _clamp_transpose(transpose_amount, ns_min_pitch, ns_max_pitch,\n min_allowed_pitch, max_allowed_pitch):\n \"\"\"Clamps the specified transpose amount to keep a ns in the desired bounds.\n\n Args:\n transpose_amount: Number of steps to transpose up or down.\n ns_min_pitch: The lowest pitch in the target note sequence.\n ns_max_pitch: The highest pitch in the target note sequence.\n min_allowed_pitch: The lowest pitch that should be allowed in the transposed\n note sequence.\n max_allowed_pitch: The highest pitch that should be allowed in the\n transposed note sequence.\n\n Returns:\n A new transpose amount that, if applied to the target note sequence, will\n keep all notes within the range [MIN_PITCH, MAX_PITCH]\n \"\"\"\n if transpose_amount < 0:\n transpose_amount = -min(ns_min_pitch - min_allowed_pitch,\n abs(transpose_amount))\n else:\n transpose_amount = min(max_allowed_pitch - ns_max_pitch, transpose_amount)\n return transpose_amount\n\n\ndef augment_note_sequence(ns,\n min_stretch_factor,\n max_stretch_factor,\n min_transpose,\n max_transpose,\n min_allowed_pitch=constants.MIN_MIDI_PITCH,\n max_allowed_pitch=constants.MAX_MIDI_PITCH,\n delete_out_of_range_notes=False):\n \"\"\"Modifed a NoteSequence with random stretching and transposition.\n\n This method can be used to augment a dataset for training neural nets.\n Note that the provided ns is modified in place.\n\n Args:\n ns: A NoteSequence proto to be augmented.\n min_stretch_factor: Minimum amount to stretch/compress the NoteSequence.\n max_stretch_factor: Maximum amount to stretch/compress the NoteSequence.\n min_transpose: Minimum number of steps to transpose the NoteSequence.\n max_transpose: Maximum number of steps to transpose the NoteSequence.\n min_allowed_pitch: The lowest pitch permitted (ie, for regular piano this\n should be set to 21.)\n max_allowed_pitch: The highest pitch permitted (ie, for regular piano this\n should be set to 108.)\n delete_out_of_range_notes: If true, a transposition amount will be chosen on\n the interval [min_transpose, max_transpose], and any out-of-bounds notes\n will be deleted. If false, the interval [min_transpose, max_transpose]\n will be truncated such that no out-of-bounds notes will ever be created.\n TODO(dei): Add support for specifying custom distributions over possible\n values of note stretch and transposition amount.\n\n Returns:\n The randomly augmented NoteSequence.\n\n Raises:\n ValueError: If mins in ranges are larger than maxes.\n \"\"\"\n if min_stretch_factor > max_stretch_factor:\n raise ValueError('min_stretch_factor should be <= max_stretch_factor')\n if min_allowed_pitch > max_allowed_pitch:\n raise ValueError('min_allowed_pitch should be <= max_allowed_pitch')\n if min_transpose > max_transpose:\n raise ValueError('min_transpose should be <= max_transpose')\n\n if ns.notes:\n # Choose random factor by which to stretch or compress note sequence.\n stretch_factor = random.uniform(min_stretch_factor, max_stretch_factor)\n ns = stretch_note_sequence(ns, stretch_factor, in_place=True)\n\n # Choose amount by which to translate the note sequence.\n if delete_out_of_range_notes:\n # If transposition takes a note outside of the allowed note bounds,\n # we will just delete it.\n transposition_amount = random.randint(min_transpose, max_transpose)\n else:\n # Prevent transposition from taking a note outside of the allowed note\n # bounds by clamping the range we sample from.\n ns_min_pitch = min(ns.notes, key=lambda note: note.pitch).pitch\n ns_max_pitch = max(ns.notes, key=lambda note: note.pitch).pitch\n\n if ns_min_pitch < min_allowed_pitch:\n tf.logging.warn(\n 'A note sequence has some pitch=%d, which is less '\n 'than min_allowed_pitch=%d' % (ns_min_pitch, min_allowed_pitch))\n if ns_max_pitch > max_allowed_pitch:\n tf.logging.warn(\n 'A note sequence has some pitch=%d, which is greater '\n 'than max_allowed_pitch=%d' % (ns_max_pitch, max_allowed_pitch))\n\n min_transpose = _clamp_transpose(min_transpose, ns_min_pitch,\n ns_max_pitch, min_allowed_pitch,\n max_allowed_pitch)\n max_transpose = _clamp_transpose(max_transpose, ns_min_pitch,\n ns_max_pitch, min_allowed_pitch,\n max_allowed_pitch)\n transposition_amount = random.randint(min_transpose, max_transpose)\n\n ns, _ = transpose_note_sequence(\n ns,\n transposition_amount,\n min_allowed_pitch,\n max_allowed_pitch,\n in_place=True)\n\n return ns\n\n\ndef stretch_note_sequence(note_sequence, stretch_factor, in_place=False):\n \"\"\"Apply a constant temporal stretch to a NoteSequence proto.\n\n Args:\n note_sequence: The NoteSequence to stretch.\n stretch_factor: How much to stretch the NoteSequence. Values greater than\n one increase the length of the NoteSequence (making it \"slower\"). Values\n less than one decrease the length of the NoteSequence (making it\n \"faster\").\n in_place: If True, the input note_sequence is edited directly.\n\n Returns:\n A stretched copy of the original NoteSequence.\n\n Raises:\n QuantizationStatusError: If the `note_sequence` is quantized. Only\n unquantized NoteSequences can be stretched.\n \"\"\"\n if is_quantized_sequence(note_sequence):\n raise QuantizationStatusError(\n 'Can only stretch unquantized NoteSequence.')\n\n if in_place:\n stretched_sequence = note_sequence\n else:\n stretched_sequence = music_pb2.NoteSequence()\n stretched_sequence.CopyFrom(note_sequence)\n\n if stretch_factor == 1.0:\n return stretched_sequence\n\n # Stretch all notes.\n for note in stretched_sequence.notes:\n note.start_time *= stretch_factor\n note.end_time *= stretch_factor\n stretched_sequence.total_time *= stretch_factor\n\n # Stretch all other event times.\n events = itertools.chain(\n stretched_sequence.time_signatures, stretched_sequence.key_signatures,\n stretched_sequence.tempos, stretched_sequence.pitch_bends,\n stretched_sequence.control_changes, stretched_sequence.text_annotations)\n for event in events:\n event.time *= stretch_factor\n\n # Stretch tempos.\n for tempo in stretched_sequence.tempos:\n tempo.qpm /= stretch_factor\n\n return stretched_sequence\n\n\ndef adjust_notesequence_times(ns, time_func, minimum_duration=None):\n \"\"\"Adjusts notesequence timings given an adjustment function.\n\n Note that only notes, control changes, and pitch bends are adjusted. All other\n events are ignored.\n\n If the adjusted version of a note ends before or at the same time it begins,\n it will be skipped.\n\n Args:\n ns: The NoteSequence to adjust.\n time_func: A function that takes a time (in seconds) and returns an adjusted\n version of that time. This function is expected to be monotonic, i.e. if\n `t1 <= t2` then `time_func(t1) <= time_func(t2)`. In addition, if\n `t >= 0` then it should also be true that `time_func(t) >= 0`. The\n monotonicity property is not checked for all pairs of event times, only\n the start and end times of each note, but you may get strange results if\n `time_func` is non-monotonic.\n minimum_duration: If time_func results in a duration of 0, instead\n substitute this duration and do not increment the skipped_notes counter.\n If None, the note will be skipped.\n\n Raises:\n InvalidTimeAdjustmentError: If a note has an adjusted end time that is\n before its start time, or if any event times are shifted before zero.\n\n Returns:\n adjusted_ns: A new NoteSequence with adjusted times.\n skipped_notes: A count of how many notes were skipped.\n \"\"\"\n adjusted_ns = copy.deepcopy(ns)\n\n # Iterate through the original NoteSequence notes to make it easier to drop\n # skipped notes from the adjusted NoteSequence.\n adjusted_ns.total_time = 0\n skipped_notes = 0\n del adjusted_ns.notes[:]\n for note in ns.notes:\n start_time = time_func(note.start_time)\n end_time = time_func(note.end_time)\n\n if start_time == end_time:\n if minimum_duration:\n tf.logging.warn(\n 'Adjusting note duration of 0 to new minimum duration of %f. '\n 'Original start: %f, end %f. New start %f, end %f.',\n minimum_duration, note.start_time, note.end_time, start_time,\n end_time)\n end_time += minimum_duration\n else:\n tf.logging.warn(\n 'Skipping note that ends before or at the same time it begins. '\n 'Original start: %f, end %f. New start %f, end %f.',\n note.start_time, note.end_time, start_time, end_time)\n skipped_notes += 1\n continue\n\n if end_time < start_time:\n raise InvalidTimeAdjustmentError(\n 'Tried to adjust end time to before start time. '\n 'Original start: %f, end %f. New start %f, end %f.' %\n (note.start_time, note.end_time, start_time, end_time))\n\n if start_time < 0:\n raise InvalidTimeAdjustmentError(\n 'Tried to adjust note start time to before 0 '\n '(original: %f, adjusted: %f)' % (note.start_time, start_time))\n\n if end_time < 0:\n raise InvalidTimeAdjustmentError(\n 'Tried to adjust note end time to before 0 '\n '(original: %f, adjusted: %f)' % (note.end_time, end_time))\n\n if end_time > adjusted_ns.total_time:\n adjusted_ns.total_time = end_time\n\n adjusted_note = adjusted_ns.notes.add()\n adjusted_note.MergeFrom(note)\n adjusted_note.start_time = start_time\n adjusted_note.end_time = end_time\n\n events = itertools.chain(\n adjusted_ns.control_changes,\n adjusted_ns.pitch_bends,\n adjusted_ns.time_signatures,\n adjusted_ns.key_signatures,\n adjusted_ns.text_annotations\n )\n\n for event in events:\n time = time_func(event.time)\n if time < 0:\n raise InvalidTimeAdjustmentError(\n 'Tried to adjust event time to before 0 '\n '(original: %f, adjusted: %f)' % (event.time, time))\n event.time = time\n\n # Adjusting tempos to accommodate arbitrary time adjustments is too\n # complicated. Just delete them.\n del adjusted_ns.tempos[:]\n\n return adjusted_ns, skipped_notes\n\n\ndef rectify_beats(sequence, beats_per_minute):\n \"\"\"Warps a NoteSequence so that beats happen at regular intervals.\n\n Args:\n sequence: The source NoteSequence. Will not be modified.\n beats_per_minute: Desired BPM of the rectified sequence.\n\n Returns:\n rectified_sequence: A copy of `sequence` with times adjusted so that beats\n occur at regular intervals with BPM `beats_per_minute`.\n alignment: An N-by-2 array where each row contains the original and\n rectified times for a beat.\n\n Raises:\n QuantizationStatusError: If `sequence` is quantized.\n RectifyBeatsError: If `sequence` has no beat annotations.\n \"\"\"\n if is_quantized_sequence(sequence):\n raise QuantizationStatusError(\n 'Cannot rectify beat times for quantized NoteSequence.')\n\n beat_times = [\n ta.time for ta in sequence.text_annotations\n if ta.annotation_type == music_pb2.NoteSequence.TextAnnotation.BEAT\n and ta.time <= sequence.total_time\n ]\n\n if not beat_times:\n raise RectifyBeatsError('No beats in NoteSequence.')\n\n # Add a beat at the very beginning and end of the sequence and dedupe.\n sorted_beat_times = [0.0] + sorted(beat_times) + [sequence.total_time]\n unique_beat_times = np.array([\n sorted_beat_times[i] for i in range(len(sorted_beat_times))\n if i == 0 or sorted_beat_times[i] > sorted_beat_times[i - 1]\n ])\n num_beats = len(unique_beat_times)\n\n # Use linear interpolation to map original times to rectified times.\n seconds_per_beat = 60.0 / beats_per_minute\n rectified_beat_times = seconds_per_beat * np.arange(num_beats)\n def time_func(t):\n return np.interp(t, unique_beat_times, rectified_beat_times,\n left=0.0, right=sequence.total_time)\n\n rectified_sequence, _ = adjust_notesequence_times(sequence, time_func)\n\n # Sequence probably shouldn't have time signatures but delete them just to be\n # sure, and add a single tempo.\n del rectified_sequence.time_signatures[:]\n rectified_sequence.tempos.add(qpm=beats_per_minute)\n\n return rectified_sequence, np.array([unique_beat_times,\n rectified_beat_times]).T\n\n\n# Constants for processing the note/sustain stream.\n# The order here matters because we we want to process 'on' events before we\n# process 'off' events, and we want to process sustain events before note\n# events.\n_SUSTAIN_ON = 0\n_SUSTAIN_OFF = 1\n_NOTE_ON = 2\n_NOTE_OFF = 3\n\n\ndef apply_sustain_control_changes(note_sequence, sustain_control_number=64):\n \"\"\"Returns a new NoteSequence with sustain pedal control changes applied.\n\n Extends each note within a sustain to either the beginning of the next note of\n the same pitch or the end of the sustain period, whichever happens first. This\n is done on a per instrument basis, so notes are only affected by sustain\n events for the same instrument.\n\n Args:\n note_sequence: The NoteSequence for which to apply sustain. This object will\n not be modified.\n sustain_control_number: The MIDI control number for sustain pedal. Control\n events with this number and value 0-63 will be treated as sustain pedal\n OFF events, and control events with this number and value 64-127 will be\n treated as sustain pedal ON events.\n\n Returns:\n A copy of `note_sequence` but with note end times extended to account for\n sustain.\n\n Raises:\n QuantizationStatusError: If `note_sequence` is quantized. Sustain can\n only be applied to unquantized note sequences.\n \"\"\"\n if is_quantized_sequence(note_sequence):\n raise QuantizationStatusError(\n 'Can only apply sustain to unquantized NoteSequence.')\n\n sequence = copy.deepcopy(note_sequence)\n\n # Sort all note on/off and sustain on/off events.\n events = []\n events.extend([(note.start_time, _NOTE_ON, note) for note in sequence.notes])\n events.extend([(note.end_time, _NOTE_OFF, note) for note in sequence.notes])\n\n for cc in sequence.control_changes:\n if cc.control_number != sustain_control_number:\n continue\n value = cc.control_value\n if value < 0 or value > 127:\n tf.logging.warn('Sustain control change has out of range value: %d',\n value)\n if value >= 64:\n events.append((cc.time, _SUSTAIN_ON, cc))\n elif value < 64:\n events.append((cc.time, _SUSTAIN_OFF, cc))\n\n # Sort, using the event type constants to ensure the order events are\n # processed.\n events.sort(key=operator.itemgetter(0))\n\n # Lists of active notes, keyed by instrument.\n active_notes = collections.defaultdict(list)\n # Whether sustain is active for a given instrument.\n sus_active = collections.defaultdict(lambda: False)\n\n # Iterate through all sustain on/off and note on/off events in order.\n time = 0\n for time, event_type, event in events:\n if event_type == _SUSTAIN_ON:\n sus_active[event.instrument] = True\n elif event_type == _SUSTAIN_OFF:\n sus_active[event.instrument] = False\n # End all notes for the instrument that were being extended.\n new_active_notes = []\n for note in active_notes[event.instrument]:\n if note.end_time < time:\n # This note was being extended because of sustain.\n # Update the end time and don't keep it in the list.\n note.end_time = time\n if time > sequence.total_time:\n sequence.total_time = time\n else:\n # This note is actually still active, keep it.\n new_active_notes.append(note)\n active_notes[event.instrument] = new_active_notes\n elif event_type == _NOTE_ON:\n if sus_active[event.instrument]:\n # If sustain is on, end all previous notes with the same pitch.\n new_active_notes = []\n for note in active_notes[event.instrument]:\n if note.pitch == event.pitch:\n note.end_time = time\n if note.start_time == note.end_time:\n # This note now has no duration because another note of the same\n # pitch started at the same time. Only one of these notes should\n # be preserved, so delete this one.\n # TODO(fjord): A more correct solution would probably be to\n # preserve both notes and make the same duration, but that is a\n # little more complicated to implement. Will keep this solution\n # until we find that we need the more complex one.\n sequence.notes.remove(note)\n else:\n new_active_notes.append(note)\n active_notes[event.instrument] = new_active_notes\n # Add this new note to the list of active notes.\n active_notes[event.instrument].append(event)\n elif event_type == _NOTE_OFF:\n if sus_active[event.instrument]:\n # Note continues until another note of the same pitch or sustain ends.\n pass\n else:\n # Remove this particular note from the active list.\n # It may have already been removed if a note of the same pitch was\n # played when sustain was active.\n if event in active_notes[event.instrument]:\n active_notes[event.instrument].remove(event)\n else:\n raise AssertionError('Invalid event_type: %s' % event_type)\n\n # End any notes that were still active due to sustain.\n for instrument in active_notes.values():\n for note in instrument:\n note.end_time = time\n sequence.total_time = time\n\n return sequence\n\n\ndef infer_dense_chords_for_sequence(sequence,\n instrument=None,\n min_notes_per_chord=3):\n \"\"\"Infers chords for a NoteSequence and adds them as TextAnnotations.\n\n For each set of simultaneously-active notes in a NoteSequence (optionally for\n only one instrument), infers a chord symbol and adds it to NoteSequence as a\n TextAnnotation. Every change in the set of active notes will result in a new\n chord symbol unless the new set is smaller than `min_notes_per_chord`.\n\n If `sequence` is quantized, simultaneity will be determined by quantized steps\n instead of time.\n\n Not to be confused with the chord inference in magenta.music.chord_inference\n that attempts to infer a more natural chord sequence with changes at regular\n metric intervals.\n\n Args:\n sequence: The NoteSequence for which chords will be inferred. Will be\n modified in place.\n instrument: The instrument number whose notes will be used for chord\n inference. If None, all instruments will be used.\n min_notes_per_chord: The minimum number of simultaneous notes for which to\n infer a chord.\n\n Raises:\n ChordSymbolError: If a chord cannot be determined for a set of\n simultaneous notes in `sequence`.\n \"\"\"\n notes = [\n note for note in sequence.notes if not note.is_drum and\n (instrument is None or note.instrument == instrument)\n ]\n sorted_notes = sorted(notes, key=lambda note: note.start_time)\n\n # If the sequence is quantized, use quantized steps instead of time.\n if is_quantized_sequence(sequence):\n note_start = lambda note: note.quantized_start_step\n note_end = lambda note: note.quantized_end_step\n else:\n note_start = lambda note: note.start_time\n note_end = lambda note: note.end_time\n\n # Sort all note start and end events.\n onsets = [\n (note_start(note), idx, False) for idx, note in enumerate(sorted_notes)\n ]\n offsets = [\n (note_end(note), idx, True) for idx, note in enumerate(sorted_notes)\n ]\n events = sorted(onsets + offsets)\n\n current_time = 0\n current_figure = constants.NO_CHORD\n active_notes = set()\n\n for time, idx, is_offset in events:\n if time > current_time:\n active_pitches = set(sorted_notes[idx].pitch for idx in active_notes)\n if len(active_pitches) >= min_notes_per_chord:\n # Infer a chord symbol for the active pitches.\n figure = chord_symbols_lib.pitches_to_chord_symbol(active_pitches)\n\n if figure != current_figure:\n # Add a text annotation to the sequence.\n text_annotation = sequence.text_annotations.add()\n text_annotation.text = figure\n text_annotation.annotation_type = CHORD_SYMBOL\n if is_quantized_sequence(sequence):\n text_annotation.time = (\n current_time * sequence.quantization_info.steps_per_quarter)\n text_annotation.quantized_step = current_time\n else:\n text_annotation.time = current_time\n\n current_figure = figure\n\n current_time = time\n if is_offset:\n active_notes.remove(idx)\n else:\n active_notes.add(idx)\n\n assert not active_notes\n\n\nPianoroll = collections.namedtuple( # pylint:disable=invalid-name\n 'Pianoroll',\n ['active', 'weights', 'onsets', 'onset_velocities', 'active_velocities',\n 'offsets', 'control_changes'])\n\n\ndef sequence_to_pianoroll(\n sequence,\n frames_per_second,\n min_pitch,\n max_pitch,\n # pylint: disable=unused-argument\n min_velocity=constants.MIN_MIDI_PITCH,\n # pylint: enable=unused-argument\n max_velocity=constants.MAX_MIDI_PITCH,\n add_blank_frame_before_onset=False,\n onset_upweight=ONSET_UPWEIGHT,\n onset_window=ONSET_WINDOW,\n onset_length_ms=0,\n offset_length_ms=0,\n onset_mode='window',\n onset_delay_ms=0.0,\n min_frame_occupancy_for_label=0.0,\n onset_overlap=True):\n \"\"\"Transforms a NoteSequence to a pianoroll assuming a single instrument.\n\n This function uses floating point internally and may return different results\n on different platforms or with different compiler settings or with\n different compilers.\n\n Args:\n sequence: The NoteSequence to convert.\n frames_per_second: How many frames per second.\n min_pitch: pitches in the sequence below this will be ignored.\n max_pitch: pitches in the sequence above this will be ignored.\n min_velocity: minimum velocity for the track, currently unused.\n max_velocity: maximum velocity for the track, not just the local sequence,\n used to globally normalize the velocities between [0, 1].\n add_blank_frame_before_onset: Always have a blank frame before onsets.\n onset_upweight: Factor by which to increase the weight assigned to onsets.\n onset_window: Fixed window size to activate around onsets in `onsets` and\n `onset_velocities`. Used only if `onset_mode` is 'window'.\n onset_length_ms: Length in milliseconds for the onset. Used only if\n onset_mode is 'length_ms'.\n offset_length_ms: Length in milliseconds for the offset. Used only if\n offset_mode is 'length_ms'.\n onset_mode: Either 'window', to use onset_window, or 'length_ms' to use\n onset_length_ms.\n onset_delay_ms: Number of milliseconds to delay the onset. Can be negative.\n min_frame_occupancy_for_label: floating point value in range [0, 1] a note\n must occupy at least this percentage of a frame, for the frame to be given\n a label with the note.\n onset_overlap: Whether or not the onsets overlap with the frames.\n\n Raises:\n ValueError: When an unknown onset_mode is supplied.\n\n Returns:\n active: Active note pianoroll as a 2D array..\n weights: Weights to be used when calculating loss against roll.\n onsets: An onset-only pianoroll as a 2D array.\n onset_velocities: Velocities of onsets scaled from [0, 1].\n active_velocities: Velocities of active notes scaled from [0, 1].\n offsets: An offset-only pianoroll as a 2D array.\n control_changes: Control change onsets as a 2D array (time, control number)\n with 0 when there is no onset and (control_value + 1) when there is.\n \"\"\"\n roll = np.zeros((int(sequence.total_time * frames_per_second + 1),\n max_pitch - min_pitch + 1),\n dtype=np.float32)\n\n roll_weights = np.ones_like(roll)\n\n onsets = np.zeros_like(roll)\n offsets = np.zeros_like(roll)\n\n control_changes = np.zeros(\n (int(sequence.total_time * frames_per_second + 1), 128), dtype=np.int32)\n\n def frames_from_times(start_time, end_time):\n \"\"\"Converts start/end times to start/end frames.\"\"\"\n # Will round down because note may start or end in the middle of the frame.\n start_frame = int(start_time * frames_per_second)\n start_frame_occupancy = (start_frame + 1 - start_time * frames_per_second)\n # check for > 0.0 to avoid possible numerical issues\n if (min_frame_occupancy_for_label > 0.0 and\n start_frame_occupancy < min_frame_occupancy_for_label):\n start_frame += 1\n\n end_frame = int(math.ceil(end_time * frames_per_second))\n end_frame_occupancy = end_time * frames_per_second - start_frame - 1\n if (min_frame_occupancy_for_label > 0.0 and\n end_frame_occupancy < min_frame_occupancy_for_label):\n end_frame -= 1\n # can be a problem for very short notes\n end_frame = max(start_frame, end_frame)\n\n return start_frame, end_frame\n\n velocities_roll = np.zeros_like(roll, dtype=np.float32)\n\n for note in sorted(sequence.notes, key=lambda n: n.start_time):\n if note.pitch < min_pitch or note.pitch > max_pitch:\n tf.logging.warn('Skipping out of range pitch: %d', note.pitch)\n continue\n start_frame, end_frame = frames_from_times(note.start_time, note.end_time)\n\n # label onset events. Use a window size of onset_window to account of\n # rounding issue in the start_frame computation.\n onset_start_time = note.start_time + onset_delay_ms / 1000.\n onset_end_time = note.end_time + onset_delay_ms / 1000.\n if onset_mode == 'window':\n onset_start_frame_without_window, _ = frames_from_times(\n onset_start_time, onset_end_time)\n\n onset_start_frame = max(0,\n onset_start_frame_without_window - onset_window)\n onset_end_frame = min(onsets.shape[0],\n onset_start_frame_without_window + onset_window + 1)\n elif onset_mode == 'length_ms':\n onset_end_time = min(onset_end_time,\n onset_start_time + onset_length_ms / 1000.)\n onset_start_frame, onset_end_frame = frames_from_times(\n onset_start_time, onset_end_time)\n else:\n raise ValueError('Unknown onset mode: {}'.format(onset_mode))\n\n # label offset events.\n offset_start_time = min(note.end_time,\n sequence.total_time - offset_length_ms / 1000.)\n offset_end_time = offset_start_time + offset_length_ms / 1000.\n offset_start_frame, offset_end_frame = frames_from_times(\n offset_start_time, offset_end_time)\n offset_end_frame = max(offset_end_frame, offset_start_frame + 1)\n\n if not onset_overlap:\n start_frame = onset_end_frame\n end_frame = max(start_frame + 1, end_frame)\n\n offsets[offset_start_frame:offset_end_frame, note.pitch - min_pitch] = 1.0\n onsets[onset_start_frame:onset_end_frame, note.pitch - min_pitch] = 1.0\n roll[start_frame:end_frame, note.pitch - min_pitch] = 1.0\n\n if note.velocity > max_velocity:\n raise ValueError('Note velocity exceeds max velocity: %d > %d' %\n (note.velocity, max_velocity))\n\n velocities_roll[start_frame:end_frame, note.pitch -\n min_pitch] = note.velocity / max_velocity\n roll_weights[onset_start_frame:onset_end_frame, note.pitch - min_pitch] = (\n onset_upweight)\n roll_weights[onset_end_frame:end_frame, note.pitch - min_pitch] = [\n onset_upweight / x for x in range(1, end_frame - onset_end_frame + 1)\n ]\n\n if add_blank_frame_before_onset:\n if start_frame > 0:\n roll[start_frame - 1, note.pitch - min_pitch] = 0.0\n roll_weights[start_frame - 1, note.pitch - min_pitch] = 1.0\n\n for cc in sequence.control_changes:\n frame, _ = frames_from_times(cc.time, 0)\n if frame < len(control_changes):\n control_changes[frame, cc.control_number] = cc.control_value + 1\n\n return Pianoroll(\n active=roll,\n weights=roll_weights,\n onsets=onsets,\n onset_velocities=velocities_roll * onsets,\n active_velocities=velocities_roll,\n offsets=offsets,\n control_changes=control_changes)\n\n\ndef pianoroll_to_note_sequence(frames,\n frames_per_second,\n min_duration_ms,\n velocity=70,\n instrument=0,\n program=0,\n qpm=constants.DEFAULT_QUARTERS_PER_MINUTE,\n min_midi_pitch=constants.MIN_MIDI_PITCH,\n onset_predictions=None,\n offset_predictions=None,\n velocity_values=None):\n \"\"\"Convert frames to a NoteSequence.\"\"\"\n frame_length_seconds = 1 / frames_per_second\n\n sequence = music_pb2.NoteSequence()\n sequence.tempos.add().qpm = qpm\n sequence.ticks_per_quarter = constants.STANDARD_PPQ\n\n pitch_start_step = {}\n onset_velocities = velocity * np.ones(\n constants.MAX_MIDI_PITCH, dtype=np.int32)\n\n # Add silent frame at the end so we can do a final loop and terminate any\n # notes that are still active.\n frames = np.append(frames, [np.zeros(frames[0].shape)], 0)\n if velocity_values is None:\n velocity_values = velocity * np.ones_like(frames, dtype=np.int32)\n\n if onset_predictions is not None:\n onset_predictions = np.append(onset_predictions,\n [np.zeros(onset_predictions[0].shape)], 0)\n # Ensure that any frame with an onset prediction is considered active.\n frames = np.logical_or(frames, onset_predictions)\n\n if offset_predictions is not None:\n offset_predictions = np.append(offset_predictions,\n [np.zeros(offset_predictions[0].shape)], 0)\n # If the frame and offset are both on, then turn it off\n frames[np.where(np.logical_and(frames > 0, offset_predictions > 0))] = 0\n\n def end_pitch(pitch, end_frame):\n \"\"\"End an active pitch.\"\"\"\n start_time = pitch_start_step[pitch] * frame_length_seconds\n end_time = end_frame * frame_length_seconds\n\n if (end_time - start_time) * 1000 >= min_duration_ms:\n note = sequence.notes.add()\n note.start_time = start_time\n note.end_time = end_time\n note.pitch = pitch + min_midi_pitch\n note.velocity = onset_velocities[pitch]\n note.instrument = instrument\n note.program = program\n\n del pitch_start_step[pitch]\n\n def unscale_velocity(velocity):\n \"\"\"Translates a velocity estimate to a MIDI velocity value.\"\"\"\n unscaled = max(min(velocity, 1.), 0) * 80. + 10.\n if math.isnan(unscaled):\n return 0\n return int(unscaled)\n\n def process_active_pitch(pitch, i):\n \"\"\"Process a pitch being active in a given frame.\"\"\"\n if pitch not in pitch_start_step:\n if onset_predictions is not None:\n # If onset predictions were supplied, only allow a new note to start\n # if we've predicted an onset.\n if onset_predictions[i, pitch]:\n pitch_start_step[pitch] = i\n onset_velocities[pitch] = unscale_velocity(velocity_values[i, pitch])\n else:\n # Even though the frame is active, the onset predictor doesn't\n # say there should be an onset, so ignore it.\n pass\n else:\n pitch_start_step[pitch] = i\n else:\n if onset_predictions is not None:\n # pitch is already active, but if this is a new onset, we should end\n # the note and start a new one.\n if (onset_predictions[i, pitch] and\n not onset_predictions[i - 1, pitch]):\n end_pitch(pitch, i)\n pitch_start_step[pitch] = i\n onset_velocities[pitch] = unscale_velocity(velocity_values[i, pitch])\n\n for i, frame in enumerate(frames):\n for pitch, active in enumerate(frame):\n if active:\n process_active_pitch(pitch, i)\n elif pitch in pitch_start_step:\n end_pitch(pitch, i)\n\n sequence.total_time = len(frames) * frame_length_seconds\n if sequence.notes:\n assert sequence.total_time >= sequence.notes[-1].end_time\n\n return sequence\n"
] |
[
[
"numpy.logical_or",
"numpy.zeros_like",
"numpy.ones_like",
"numpy.array",
"numpy.zeros",
"numpy.ones",
"numpy.interp",
"numpy.logical_and",
"numpy.arange",
"tensorflow.logging.warn"
]
] |
TACC/GravIT
|
[
"0a79dc74036c11669075198e01b30a92a8150693"
] |
[
"pygvt/cosmology_plus.py"
] |
[
"#\n# cosmology_plus.py\n#\n# read and render the first two levels of the cosmology plus\n# enzo dataset. There are actually 5 levels of refinement\n# but the first two levels contain 37 grids. \n#\n# This script is rough. It is only intended to test the python\n# wrappers for amr grids. \n# to run this from inside the interpreter do\n# exec(open('cosmology_plus.py').read())\n#\n# Import the required libs.\n#\nimport gvt\nimport h5py\nimport os\nfrom mpi4py import MPI\nimport numpy as np\n#from vtk import vtkStructuredPointsReader, vtkStructuredPoints\n#\n# initialize GraviT\n#\ngvt.gvtInit()\n#\n# MPI business\n#\ncomm = MPI.COMM_WORLD\nrank = comm.Get_rank()\nnumprocs = comm.size\n#\nprint(\" numprocs \" + str(numprocs) + \" rank \" + str(rank))\n#\n#\n# where are the data\n#\ndata_dir = os.path.join(os.environ['WORK'],\"Projects/GraviT/data/enzo_cosmology_plus\")\ngravit_dir = os.path.join(os.environ['WORK'],\"Projects/GraviT\")\n# going to want to run this from the data directory\n# so all the relative links work\nimagedir = os.getcwd()\nos.chdir(data_dir)\n# input files \nvolumefile = os.path.join(data_dir,\"DD0046/DD0046.hierarchy.hdf5\")\n#ctffile = os.path.join(gravit_dir,\"data/colormaps/Grayscale.orig.cmap\")\n#otffile = os.path.join(gravit_dir,\"data/colormaps/Grayscale.orig.omap\")\n#ctffile = os.path.join(gravit_dir,\"data/colormaps/CoolWarm.cmap\")\notffile = os.path.join(gravit_dir,\"data/colormaps/blue2cyan.omap\")\n#otffile = os.path.join(gravit_dir,\"data/colormaps/ramp.omap\")\n#ctffile = os.path.join(gravit_dir,\"data/colormaps/blue2cyan.cmap\")\n#ctffile = os.path.join(gravit_dir,\"data/colormaps/IceFire.cmap\")\n#ctffile = os.path.join(gravit_dir,\"data/colormaps/Jet.cmap\")\nctffile = os.path.join(gravit_dir,\"data/colormaps/coldhot.cmap\")\n#ctffile = os.path.join(gravit_dir,\"data/colormaps/orange-5.cmap\")\n#otffile = os.path.join(gravit_dir,\"data/colormaps/orange-5.omap\")\n#ctffile = os.path.join(gravit_dir,\"data/colormaps/Balls.cmap\")\n#otffile = os.path.join(gravit_dir,\"data/colormaps/Balls.omap\")\n#\nroot=h5py.File(volumefile)\n# the number of domains is the number of grids in level 0\nlevel0 = root['Level0']\nnumberofdomains = level0.attrs[\"NumberOfGrids\"]\nlevel0grids = list(level0.keys())\nlow_scalar = np.finfo('float32').max\nhigh_scalar = np.finfo('float32').min\nsamplingrate = 1.0\nk = 0\n#for domain in range(1):\nfor domain in range(numberofdomains):\n level = 0 \n if(domain%numprocs == rank): # read the domain (grid)\n nodename = \"enzo_cosmology_plus_domain_\" + repr(domain)\n# print(\" creating node \" + nodename)\n gvt.createVolume(nodename,True)\n gridname = level0grids[domain]\n grid = level0[gridname]\n griddata = grid.get('GridData')\n density = griddata['Density']\n with density.astype('float32'):\n scalars = density[()]\n scalardims = np.array(scalars.shape,dtype=np.int32)\n low_scalar= min(low_scalar,scalars.min())\n high_scalar= max(high_scalar,scalars.max())\n #dimensions = grid['GridDimension'].value\n startindex = grid['GridStartIndex'][()]\n endindex = grid['GridEndIndex'][()]\n dimensions = (endindex - startindex)+1 \n #dimensions = scalardims\n origin = grid['GridGlobalPosition'][()]\n left = grid['GridLeftEdge'][()]\n right = grid['GridRightEdge'][()]\n spacing = (right - left)/(dimensions)\n right = left + spacing*(dimensions)\n bounds = np.array([left[0],right[0],left[1],right[1],left[2],right[2]])\n # stuff the level grid full\n# print(\"\\tdims \"+repr(dimensions[:]))\n# print(\"\\tsdims \"+repr(scalardims[:]))\n# print(\"\\tleft \" + repr(left[:]))\n# print(\"\\tspacing \" + repr(spacing))\n# print(\"\\tsampling \" + repr(samplingrate))\n# print(\"\\tbounds \" + repr(bounds))\n #fltptr = scalars.flatten()\n fltptr = np.ravel(scalars,order='C')\n# print(\"\\tfloats \" + repr(fltptr[0]) + \" \" +repr(fltptr[1] ))\n# print(\"level \" + repr(level) + \" gridname \" + gridname +\" nodename \"+ nodename)\n gvt.addVolumeSamples(nodename,fltptr.astype(np.float32),dimensions.astype(np.int32),left.astype(np.float32),spacing.astype(np.float32),samplingrate,bounds.astype(np.float64))\n # grab the subgrids or daughters of this grid\n daughtergrids = grid['DaughterGrids']\n dglist = list(daughtergrids.keys())\n numsubs = len(dglist)\n #for l in range(0):\n for dgname in daughtergrids.keys():\n #dgname = dglist[l]\n level = 1\n k = k + 1\n grid = daughtergrids[dgname]\n griddata = grid.get('GridData')\n density = griddata['Density']\n with density.astype('float32'):\n scalars = density[()]\n scalardims = np.array(scalars.shape,dtype=np.int32) -1\n low_scalar= min(low_scalar,scalars.min())\n high_scalar= max(high_scalar,scalars.max())\n #dimensions = grid['GridDimension'].value\n startindex = grid['GridStartIndex'][()]\n endindex = grid['GridEndIndex'][()]\n dimensions = endindex - startindex \n origin = grid['GridGlobalPosition'][()]\n left = grid['GridLeftEdge'][()]\n right = grid['GridRightEdge'][()]\n bounds = np.array([left[0],right[0],left[1],right[1],left[2],right[2]])\n spacing = (right - left)/(endindex-startindex +1)\n# print(\"\\t\"+dgname)\n# print(\"\\t\\tdims \"+repr(dimensions[:]))\n# print(\"\\t\\tleft \" + repr(left[:]))\n# print(\"\\t\\tright \" + repr(right[:]))\n# print(\"\\t\\tspacing \" + repr(spacing))\n# print(\"\\tbounds \" + repr(bounds))\n fltptr = scalars.flatten()\n# print(\"level \"+repr(level)+\" gridname \"+dgname+\" nodename \"+nodename)\n gvt.addAmrSubgrid(nodename,k,level,fltptr.astype(np.float32),dimensions.astype(np.int32),left.astype(np.float32),spacing.astype(np.float32))\n print(\" add transfer functions \" + nodename)\n print(\" ctffile : \" + ctffile)\n print(\" otffile : \" + otffile)\n low_scalar = 0.10\n high_scalar = 42.0\n print(\" scalar range : \" + repr(low_scalar) + \" \" + repr(high_scalar))\n gvt.addVolumeTransferFunctions(nodename,ctffile,otffile,low_scalar,high_scalar)\n # add an instance for this level 0 grid\n mf = np.identity(4,dtype=np.float32).flatten()\n myinstance = \"inst\" + repr(domain)\n gvt.addInstance(myinstance,nodename,mf)\n# and now camera etc.\n#\neyept = np.array([2.0,2.0,2.0],dtype=np.float32)\nfocus = np.array([0.4,0.6,0.5],dtype=np.float32)\nfov = 10.0*np.pi/180.0\nupVector = np.array([0.0,1.0,0.0],dtype=np.float32)\nrayMaxDepth = 1\nraysamples = 1\njitterWindowSize = 0.5\ncamname = \"conecam\"\ngvt.addCamera(camname,eyept,focus,upVector,fov,rayMaxDepth,raysamples,jitterWindowSize)\n#film\nwsize = np.array([640,640],dtype=np.int32)\nfilmname = \"conefilm\"\nimagename = \"EnzoImage\"\ngvt.addFilm(filmname,wsize[0],wsize[1],imagename)\n#render\nrendername = \"EnzoVolRenderer\"\nschedtype = 1\nadaptertype = 6\ngvt.addRenderer(rendername,adaptertype,schedtype,camname,filmname,True)\ngvt.render(rendername)\nos.chdir(imagedir)\ngvt.writeimage(rendername,imagename)\n"
] |
[
[
"numpy.identity",
"numpy.finfo",
"numpy.array",
"numpy.ravel"
]
] |
Rick-960123/centermask-mdf-master
|
[
"72147e8aae673fcaf4103ee90a6a6b73863e7fa1"
] |
[
"maskrcnn_benchmark/modeling/roi_heads/mask_head/inference.py"
] |
[
"# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\nimport numpy as np\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\n\nfrom maskrcnn_benchmark.structures.bounding_box import BoxList\n\n\n# TODO check if want to return a single BoxList or a composite\n# object\nclass MaskPostProcessor(nn.Module):\n \"\"\"\n From the results of the CNN, post process the masks\n by taking the mask corresponding to the class with max\n probability (which are of fixed size and directly output\n by the CNN) and return the masks in the mask field of the BoxList.\n\n If a masker object is passed, it will additionally\n project the masks in the image according to the locations in boxes,\n \"\"\"\n\n def __init__(self, masker=None):\n super(MaskPostProcessor, self).__init__()\n self.masker = masker\n\n def forward(self, x, boxes, miou_logits=None):\n \"\"\"\n Arguments:\n x (Tensor): the mask logits\n boxes (list[BoxList]): bounding boxes that are used as\n reference, one for ech image\n\n Returns:\n results (list[BoxList]): one BoxList for each image, containing\n the extra field mask\n \"\"\"\n if miou_logits is not None:\n # mask_prob = (x + miou_logits).sigmoid() #50k iters : 31.7/27.6\n mask_prob = (x * miou_logits).sigmoid() #50k iters : 31.7/5.6\n else:\n mask_prob = x.sigmoid()\n\n # select masks coresponding to the predicted classes\n num_masks = x.shape[0]\n labels = [bbox.get_field(\"labels\") for bbox in boxes]\n labels = torch.cat(labels)\n index = torch.arange(num_masks, device=labels.device)\n mask_prob = mask_prob[index, labels][:, None]\n\n boxes_per_image = [len(box) for box in boxes]\n mask_prob = mask_prob.split(boxes_per_image, dim=0)\n\n if self.masker:\n mask_prob = self.masker(mask_prob, boxes)\n\n results = []\n for prob, box in zip(mask_prob, boxes):\n bbox = BoxList(box.bbox, box.size, mode=\"xyxy\")\n for field in box.fields():\n bbox.add_field(field, box.get_field(field))\n bbox.add_field(\"mask\", prob)\n results.append(bbox)\n\n return results\n\n\nclass MaskPostProcessorCOCOFormat(MaskPostProcessor):\n \"\"\"\n From the results of the CNN, post process the results\n so that the masks are pasted in the image, and\n additionally convert the results to COCO format.\n \"\"\"\n\n def forward(self, x, boxes):\n import pycocotools.mask as mask_util\n import numpy as np\n\n results = super(MaskPostProcessorCOCOFormat, self).forward(x, boxes)\n for result in results:\n masks = result.get_field(\"mask\").cpu()\n rles = [\n mask_util.encode(np.array(mask[0, :, :, np.newaxis], order=\"F\"))[0]\n for mask in masks\n ]\n for rle in rles:\n rle[\"counts\"] = rle[\"counts\"].decode(\"utf-8\")\n result.add_field(\"mask\", rles)\n return results\n\n\n# the next two functions should be merged inside Masker\n# but are kept here for the moment while we need them\n# temporarily gor paste_mask_in_image\ndef expand_boxes(boxes, scale):\n w_half = (boxes[:, 2] - boxes[:, 0]) * .5\n h_half = (boxes[:, 3] - boxes[:, 1]) * .5\n x_c = (boxes[:, 2] + boxes[:, 0]) * .5\n y_c = (boxes[:, 3] + boxes[:, 1]) * .5\n\n w_half *= scale\n h_half *= scale\n\n boxes_exp = torch.zeros_like(boxes)\n boxes_exp[:, 0] = x_c - w_half\n boxes_exp[:, 2] = x_c + w_half\n boxes_exp[:, 1] = y_c - h_half\n boxes_exp[:, 3] = y_c + h_half\n return boxes_exp\n\n\ndef expand_masks(mask, padding):\n N = mask.shape[0]\n M = mask.shape[-1]\n pad2 = 2 * padding\n scale = float(M + pad2) / M\n padded_mask = mask.new_zeros((N, 1, M + pad2, M + pad2))\n padded_mask[:, :, padding:-padding, padding:-padding] = mask\n return padded_mask, scale\n\n\ndef paste_mask_in_image(mask, box, im_h, im_w, thresh=0.5, padding=1):\n padded_mask, scale = expand_masks(mask[None], padding=padding)\n mask = padded_mask[0, 0]\n box = expand_boxes(box[None], scale)[0]\n box = box.to(dtype=torch.int32)\n\n TO_REMOVE = 1\n w = box[2] - box[0] + TO_REMOVE\n h = box[3] - box[1] + TO_REMOVE\n w = max(w, 1)\n h = max(h, 1)\n\n # Set shape to [batchxCxHxW]\n mask = mask.expand((1, 1, -1, -1))\n\n # Resize mask\n mask = mask.to(torch.float32)\n mask = F.interpolate(mask, size=(h, w), mode='bilinear', align_corners=False)\n mask = mask[0][0]\n\n if thresh >= 0:\n mask = mask > thresh\n else:\n # for visualization and debugging, we also\n # allow it to return an unmodified mask\n mask = (mask * 255).to(torch.uint8)\n\n im_mask = torch.zeros((im_h, im_w), dtype=torch.uint8)\n x_0 = max(box[0], 0)\n x_1 = min(box[2] + 1, im_w)\n y_0 = max(box[1], 0)\n y_1 = min(box[3] + 1, im_h)\n\n im_mask[y_0:y_1, x_0:x_1] = mask[\n (y_0 - box[1]) : (y_1 - box[1]), (x_0 - box[0]) : (x_1 - box[0])\n ]\n return im_mask\n\n\nclass Masker(object):\n \"\"\"\n Projects a set of masks in an image on the locations\n specified by the bounding boxes\n \"\"\"\n\n def __init__(self, threshold=0.5, padding=1):\n self.threshold = threshold\n self.padding = padding\n\n def forward_single_image(self, masks, boxes):\n boxes = boxes.convert(\"xyxy\")\n im_w, im_h = boxes.size\n res = [\n paste_mask_in_image(mask[0], box, im_h, im_w, self.threshold, self.padding)\n for mask, box in zip(masks, boxes.bbox)\n ]\n if len(res) > 0:\n res = torch.stack(res, dim=0)[:, None]\n else:\n res = masks.new_empty((0, 1, masks.shape[-2], masks.shape[-1]))\n return res\n\n def __call__(self, masks, boxes):\n if isinstance(boxes, BoxList):\n boxes = [boxes]\n\n # Make some sanity check\n assert len(boxes) == len(masks), \"Masks and boxes should have the same length.\"\n\n # TODO: Is this JIT compatible?\n # If not we should make it compatible.\n results = []\n for mask, box in zip(masks, boxes):\n assert mask.shape[0] == len(box), \"Number of objects should be the same.\"\n result = self.forward_single_image(mask, box)\n results.append(result)\n return results\n\n\ndef make_roi_mask_post_processor(cfg):\n if cfg.MODEL.ROI_MASK_HEAD.POSTPROCESS_MASKS:\n mask_threshold = cfg.MODEL.ROI_MASK_HEAD.POSTPROCESS_MASKS_THRESHOLD\n masker = Masker(threshold=mask_threshold, padding=1)\n else:\n masker = None\n mask_post_processor = MaskPostProcessor(masker)\n return mask_post_processor\n"
] |
[
[
"torch.zeros",
"torch.cat",
"numpy.array",
"torch.stack",
"torch.arange",
"torch.nn.functional.interpolate",
"torch.zeros_like"
]
] |
soniaai/pyAudioAnalysis
|
[
"47414c324114a9064d30637fdf1e508f12a7387e"
] |
[
"pyAudioAnalysis/audacityAnnotation2WAVs.py"
] |
[
"import glob\nimport os\nfrom . import audioBasicIO\nimport sys\nimport csv\nimport scipy.io.wavfile as wavfile\n\n\ndef annotation2files(wavFile, csvFile):\n '''\n Break an audio stream to segments of interest, \n defined by a csv file\n \n - wavFile: path to input wavfile\n - csvFile: path to csvFile of segment limits\n \n Input CSV file must be of the format <T1>\\t<T2>\\t<Label>\n ''' \n \n [Fs, x] = audioBasicIO.readAudioFile(wavFile)\n with open(csvFile, 'rb') as csvfile:\n reader = csv.reader(csvfile, delimiter='\\t', quotechar='|')\n for j, row in enumerate(reader):\n T1 = float(row[0].replace(\",\",\".\"))\n T2 = float(row[1].replace(\",\",\".\")) \n label = \"%s_%s_%.2f_%.2f.wav\" % (wavFile, row[2], T1, T2)\n label = label.replace(\" \", \"_\")\n xtemp = x[int(round(T1*Fs)):int(round(T2*Fs))] \n print(T1, T2, label, xtemp.shape)\n wavfile.write(label, Fs, xtemp) \n\ndef main(argv):\n if argv[1] == \"-f\":\n wavFile = argv[2]\n annotationFile = argv[3]\n annotation2files(wavFile, annotationFile)\n elif argv[1] == \"-d\":\n inputFolder = argv[2]\n types = ('*.txt', '*.csv')\n annotationFilesList = []\n for files in types:\n annotationFilesList.extend(glob.glob(os.path.join(inputFolder, files)))\n for anFile in annotationFilesList:\n wavFile = os.path.splitext(anFile)[0] + \".wav\"\n if not os.path.isfile(wavFile):\n wavFile = os.path.splitext(anFile)[0] + \".mp3\"\n if not os.path.isfile(wavFile):\n print(\"Audio file not found!\")\n return\n annotation2files(wavFile, anFile)\n\n\nif __name__ == '__main__':\n # Used to extract a series of annotated WAV files based on (a) an audio file (mp3 or wav) and \n # (b) a segment annotation file e.g. a \"label\" file generated in audacity\n #\n # usage 1:\n # python audacityAnnotation2WAVs.py -f <audiofilepath> <annotationfilepath>\n # The <annotationfilepath> is actually a tab-seperated file where each line has the format <startTime>\\t<entTime>\\t<classLabel>\n # The result of this process is a series of WAV files with a file name <audiofilepath>_<startTime>_<endTime>_<classLabel>\n # \n # usage 2:\n # python audacityAnnotation2WAVs.py -d <annotationfolderpath>\n # Same but searches all .txt and .csv annotation files. Audio files are supposed to be in the same path / filename with a WAV extension\n\n main(sys.argv)\n "
] |
[
[
"scipy.io.wavfile.write"
]
] |
tonyman1008/RADAR
|
[
"b2fc944230c2fd445528a9827eea42e1a94957b8"
] |
[
"data/syn_vases/scripts/generate_synvase.py"
] |
[
"import math\nimport numpy as np\nfrom PIL import Image\nimport cv2\nimport os\nfrom glob import glob\nimport torch\nimport torchvision\nimport neural_renderer as nr\n\n\nEPS = 1e-7\n\n\ndef get_renderer(world_ori=[0,0,1], image_size=128, fov=30, renderer_min_depth=0.1, renderer_max_depth=10, fill_back=True, device='cuda:0'):\n #### camera intrinsics\n # (u) (x)\n # d * K^-1 (v) = (y)\n # (1) (z)\n\n ## renderer for visualization\n R = [[[1.,0.,0.],\n [0.,1.,0.],\n [0.,0.,1.]]]\n R = torch.FloatTensor(R).to(device)\n t = torch.FloatTensor(world_ori).to(device)\n fx = (image_size)/2/(math.tan(fov/2 *math.pi/180))\n fy = (image_size)/2/(math.tan(fov/2 *math.pi/180))\n cx = (image_size)/2\n cy = (image_size)/2\n K = [[fx, 0., cx],\n [0., fy, cy],\n [0., 0., 1.]]\n K = torch.FloatTensor(K).to(device)\n inv_K = torch.inverse(K).unsqueeze(0)\n K = K.unsqueeze(0)\n renderer = nr.Renderer(camera_mode='projection',\n light_intensity_ambient=1.0,\n light_intensity_directional=0.,\n K=K, R=R, t=t,\n near=renderer_min_depth, far=renderer_max_depth,\n image_size=image_size, orig_size=image_size,\n fill_back=fill_back,\n background_color=[1.,1.,1.])\n return renderer\n\n\ndef get_grid(H, W, normalize=True):\n if normalize:\n h_range = torch.linspace(-1,1,H)\n w_range = torch.linspace(-1,1,W)\n else:\n h_range = torch.arange(0,H)\n w_range = torch.arange(0,W)\n grid = torch.stack(torch.meshgrid([h_range, w_range]), -1).flip(2).float() # flip h,w to x,y\n return grid\n\n\ndef get_sphere_vtx(n_elev, n_azim):\n elevs = ((torch.arange(n_elev).view(n_elev, 1) +0.5) /n_elev *2 -1) *np.pi/2 # -pi/2~pi/2\n azims = ((torch.arange(n_azim).view(1, n_azim) +0.5) /n_azim *2 -1) *np.pi # -pi~pi\n xs = elevs.cos() * azims.cos()\n ys = elevs.repeat(1, n_azim).sin()\n zs = elevs.cos() * azims.sin()\n vtx = torch.stack([xs, ys, zs], 2) # ExAx3\n return vtx\n\n\ndef get_sor_vtx(sor_curve, T):\n b, h, _ = sor_curve.shape\n rs, hs = sor_curve.unbind(2) # BxH\n y = hs.view(b,h,1).repeat(1,1,T) # BxHxT\n thetas = torch.linspace(-math.pi, math.pi, T+1)[:-1].to(sor_curve.device) # T\n x = rs.unsqueeze(2) * thetas.cos().view(1,1,T) # BxHxT\n z = rs.unsqueeze(2) * thetas.sin().view(1,1,T) # BxHxT\n sor_vtx = torch.stack([x, y, z], 3) # BxHxTx3\n return sor_vtx\n\n\ndef get_sor_full_face_idx(h, w):\n idx_map = torch.arange(h*w).reshape(h,w) # HxW\n idx_map = torch.cat([idx_map, idx_map[:,:1]], 1) # Hx(W+1), connect last column to first\n faces1 = torch.stack([idx_map[:h-1,:w], idx_map[1:,:w], idx_map[:h-1,1:w+1]], -1) # (H-1)xWx3\n faces2 = torch.stack([idx_map[1:,1:w+1], idx_map[:h-1,1:w+1], idx_map[1:,:w]], -1) # (H-1)xWx3\n return torch.stack([faces1, faces2], 0).int() # 2x(H-1)xWx3\n\n\ndef get_sor_front_face_idx(h, w):\n sor_full_face_idx = get_sor_full_face_idx(h, w) # 2x(H-1)x(W//2)x3\n return sor_full_face_idx[:,:,:w//2,:]\n\n\ndef get_sor_back_face_idx(h, w):\n sor_full_face_idx = get_sor_full_face_idx(h, w) # 2x(H-1)x(W//2)x3\n return sor_full_face_idx[:,:,w//2:,:]\n\n\ndef get_tex_uv_grid(ts, h, w):\n uv_grid = get_grid(h, w, normalize=True) # -1~1, HxWx(x,y)\n ab_grid = get_grid(ts, ts, normalize=False) / (ts-1) # 0~1, txtx(x,y)\n ab_grid_uv_offsets = ab_grid * torch.FloatTensor([2/(w-1), 2/(h-1)]).view(1,1,2)\n\n tex_uv_grid1 = uv_grid[:-1,:-1,:].view(h-1, w-1, 1, 1, 2) + ab_grid_uv_offsets.view(1, 1, ts, ts, 2) # (H-1)x(W-1)xtxtx2\n tex_uv_grid2 = uv_grid[1:,1:,:].view(h-1, w-1, 1, 1, 2) - ab_grid_uv_offsets.view(1, 1, ts, ts, 2) # (H-1)x(W-1)xtxtx2\n tex_uv_grid = torch.stack([tex_uv_grid1, tex_uv_grid2], 0) # 2x(H-1)x(W-1)xtxtx2\n return tex_uv_grid\n\n\ndef get_sor_vtx_normal(sor_vtx):\n sor_vtx = torch.nn.functional.pad(sor_vtx.permute(0,3,1,2), (1,1,0,0), mode='circular').permute(0,2,3,1) # BxHx(T+2)x3\n\n tu = sor_vtx[:,1:-1,2:] - sor_vtx[:,1:-1,:-2]\n tv = sor_vtx[:,2:,1:-1] - sor_vtx[:,:-2,1:-1]\n normal = tu.cross(tv, dim=3) # Bx(H-2)xTx3\n normal = torch.nn.functional.pad(normal.permute(0,3,1,2), (0,0,1,1), mode='replicate').permute(0,2,3,1) # BxHxTx3\n normal = normal / (((normal**2).sum(3, keepdim=True))**0.5 + EPS)\n return normal # BxHxTx3\n\n\ndef get_sor_quad_center_vtx(sor_vtx):\n ## shift to quad center for shading\n sor_vtx = torch.cat([sor_vtx, sor_vtx[:,:,:1]], 2) # Hx(T+1), connect last column to first\n sor_quad_center_vtx = torch.nn.functional.avg_pool2d(sor_vtx.permute(0,3,1,2), kernel_size=2, stride=1, padding=0).permute(0,2,3,1)\n return sor_quad_center_vtx # Bx(H-1)xTx3\n\n\ndef get_sor_quad_center_normal(sor_vtx):\n ## shift to quad center for shading\n sor_vtx = torch.cat([sor_vtx, sor_vtx[:,:,:1]], 2) # Hx(T+1), connect last column to first\n\n tu = sor_vtx[:,:-1,1:] - sor_vtx[:,1:,:-1]\n tv = sor_vtx[:,1:,1:] - sor_vtx[:,:-1,:-1]\n normal = tu.cross(tv, dim=3) # Bx(H-1)xTx3\n normal = normal / (((normal**2).sum(3, keepdim=True))**0.5 + EPS)\n return normal # Bx(H-1)xTx3\n\n\ndef get_rotation_matrix(tx, ty, tz):\n m_x = torch.zeros((len(tx), 3, 3)).to(tx.device)\n m_y = torch.zeros((len(tx), 3, 3)).to(tx.device)\n m_z = torch.zeros((len(tx), 3, 3)).to(tx.device)\n\n m_x[:, 1, 1], m_x[:, 1, 2] = tx.cos(), -tx.sin()\n m_x[:, 2, 1], m_x[:, 2, 2] = tx.sin(), tx.cos()\n m_x[:, 0, 0] = 1\n\n m_y[:, 0, 0], m_y[:, 0, 2] = ty.cos(), ty.sin()\n m_y[:, 2, 0], m_y[:, 2, 2] = -ty.sin(), ty.cos()\n m_y[:, 1, 1] = 1\n\n m_z[:, 0, 0], m_z[:, 0, 1] = tz.cos(), -tz.sin()\n m_z[:, 1, 0], m_z[:, 1, 1] = tz.sin(), tz.cos()\n m_z[:, 2, 2] = 1\n return torch.matmul(m_z, torch.matmul(m_y, m_x))\n\n\ndef rotate_pts(pts, rotmat):\n return pts.matmul(rotmat.transpose(2,1))\n\n\ndef transform_sor(sor_vtx, rxyz=None, txy=None):\n if rxyz is not None:\n rx, ry, rz = rxyz.unbind(1)\n rotmat = get_rotation_matrix(rx, ry, rz).to(sor_vtx.device)\n sor_vtx = rotate_pts(sor_vtx, rotmat) # BxNx3\n if txy is not None:\n tz = torch.zeros(len(txy), 1).to(txy.device)\n txyz = torch.cat([txy, tz], 1)\n sor_vtx = sor_vtx + txyz.unsqueeze(1) # BxNx3\n return sor_vtx\n\n\ndef render_sor(renderer, sor_vtx, sor_faces, tex_im, tx_size=4, dim_inside=False):\n b, H, T, _ = sor_vtx.shape\n tex_uv_grid = get_tex_uv_grid(tx_size, H, T+1).to(sor_vtx.device) # Bx2x(H-1)x(W-1)xtxtx2\n\n tx_cube = torch.nn.functional.grid_sample(tex_im, tex_uv_grid.view(1,-1,tx_size*tx_size,2).repeat(b,1,1,1), mode='bilinear', padding_mode=\"reflection\", align_corners=False) # Bx3xFxT^2\n tx_cube = tx_cube.permute(0,2,3,1).view(b,-1,1,tx_size,tx_size,3).repeat(1,1,tx_size,1,1,1) # BxFxtxtxtx3\n\n sor_vtx = sor_vtx.view(b,-1,3)\n sor_faces = sor_faces.view(b,-1,3)\n if dim_inside:\n fill_back = renderer.fill_back\n renderer.fill_back = False\n sor_faces = torch.cat([sor_faces, sor_faces.flip(2)], 1)\n tx_cube = torch.cat([tx_cube, tx_cube*0.5], 1)\n im_rendered = renderer.render_rgb(sor_vtx, sor_faces, tx_cube)\n renderer.fill_back = fill_back\n else:\n im_rendered = renderer.render_rgb(sor_vtx, sor_faces, tx_cube)\n return im_rendered\n\n\ndef save_results(root, res, name=''):\n b = res['batch_size']\n keys = res.keys()\n os.makedirs(root, exist_ok=True)\n for i in range(b):\n idx = len(os.listdir(root)) +1\n fname = '%04d' %idx + name\n out_folder = os.path.join(root, fname)\n os.makedirs(out_folder)\n for key in keys:\n fpath = os.path.join(out_folder, fname+'_'+key)\n if key == 'batch_size':\n pass\n elif res[key].dim() == 4:\n im = np.uint8(res[key][i].permute(1,2,0).flip(2).numpy() *255)\n cv2.imwrite(fpath+'.png', im)\n else:\n np.savetxt(fpath+'.txt', res[key][i].numpy(), fmt='%.6f', delimiter=', ')\n\n\nGAMMA = 2.2\ndef HDR2LDR(img):\n return img.clamp(min=EPS) **(1/GAMMA)\n\n\ndef LDR2HDR(img):\n return img.clamp(min=EPS) **GAMMA\n\n\ndef envmap_phong_shading(point3d, albedo, spec_albedo, normal, cam_loc, ambient, env_map, spec_alpha):\n b, c, tex_h, tex_w = albedo.shape\n _, h, w, _ = point3d.shape\n\n view_dirs = cam_loc.view(1,1,1,3) - point3d\n view_dirs = torch.nn.functional.normalize(view_dirs, p=2, dim=3, eps=EPS)\n\n _, n_elev, n_azim = env_map.shape\n l_dirs = get_sphere_vtx(n_elev, n_azim).unsqueeze(0).to(point3d.device) # BxExAx3\n l_elevs = ((torch.arange(n_elev) +0.5) /n_elev *2 -1) *np.pi/2\n l_norm = l_elevs.cos().view(1, n_elev, 1).to(point3d.device) / n_elev / n_azim # 1xEx1\n l_ints = env_map * l_norm *50\n\n cos_theta = ((-normal.unsqueeze(1)) * l_dirs.view(1,n_elev*n_azim,1,1,3)).sum(4, keepdim=True)\n diffuse = l_ints.view(b,n_elev*n_azim,1,1,-1) *cos_theta.clamp(0,1) # BxLxHxWx1\n diffuse = torch.nn.functional.interpolate(diffuse.view(b*n_elev*n_azim,h,w,1).permute(0,3,1,2), (tex_h, tex_w), mode='bilinear', align_corners=False).view(b,n_elev*n_azim,1,tex_h,tex_w)\n\n reflect_dirs = -l_dirs.view(1,n_elev*n_azim,1,1,3) + 2*cos_theta*(-normal.unsqueeze(1))\n specular = (view_dirs.unsqueeze(1) * reflect_dirs).sum(4,keepdim=True).clamp(min=0) * (cos_theta>0)\n specular = (spec_alpha.view(b,1,1,1,-1)+1)/2/math.pi *l_ints.view(b,n_elev*n_azim,1,1,-1) * specular.clamp(min=EPS).pow(spec_alpha.view(b,1,1,1,-1)) # BxLxHxWx1\n specular = torch.nn.functional.interpolate(specular.view(b*n_elev*n_azim,h,w,1).permute(0,3,1,2), (tex_h, tex_w), mode='bilinear', align_corners=False).view(b,n_elev*n_azim,1,tex_h,tex_w)\n\n colors = (ambient.view(b,-1,1,1) + diffuse.sum(1)) *albedo + specular.sum(1) *spec_albedo\n return colors, diffuse, specular\n\n\ndef sg_to_env_map(sg_lights, n_elev=8, n_azim=16):\n b, n_sgls, _ = sg_lights.shape\n\n sgl_dirs = sg_lights[:,:,:3]\n sgl_lams = sg_lights[:,:,3:4]\n sgl_Fs = sg_lights[:,:,4:5]\n\n l_dirs = get_sphere_vtx(n_elev, n_azim).unsqueeze(0).to(sg_lights.device) # BxExAx3\n exps = sgl_lams.view(b,n_sgls,1,1)* ((sgl_dirs.view(b,n_sgls,1,1,3)*l_dirs.view(1,1,n_elev,n_azim,3)).sum(4)-1) # BxLxExA\n l_ints = sgl_Fs.view(b,n_sgls,1,1) * exps.exp() # BxLxExA\n env_map = l_ints.sum(1) / n_sgls # BxExA\n return env_map\n\n\ndef get_random_sor_curve(b, H):\n t1_bottom = torch.rand(b) *math.pi -math.pi # -pi~0\n t1_top = torch.rand(b) *1.5*math.pi + 0.5*math.pi # pi/2~pi*2\n amp1 = torch.rand(b) *0.3 # 0~0.3\n t2_bottom = torch.rand(b) *2*math.pi # 0~pi*2\n t2_top = t2_bottom + torch.rand(b) *1.5*math.pi + 0.5*math.pi # bottom + pi/2~pi*2\n amp2 = torch.rand(b) *0.1 # 0~0.1\n r0 = torch.rand(b) *0.2 + 0.1 # 0.02~0.3\n\n ts = torch.linspace(0,1,H)\n t1s = (1-ts.view(1,H)) * t1_bottom.view(b,1) + ts.view(1,H) * t1_top.view(b,1)\n sin1 = amp1.view(b,1) * (t1s.sin() +1)\n t2s = (1-ts.view(1,H)) * t2_bottom.view(b,1) + ts.view(1,H) * t2_top.view(b,1)\n sin2 = amp2.view(b,1) * (t2s.sin() +1)\n # r_col = sin1 + sin2 + r0.view(b,1) # 0.1~1\n # r_col = r_col / r_col.max(1)[0].view(b,1) *0.75 # normalize to 0.75\n\n ## TODO:straight axis testing\n r_col = (torch.rand(b).clamp(0.4,1)*0.75).repeat(1,32) \n\n h_scale = torch.zeros(b) + 0.75\n h_col = torch.linspace(-1,1,H).view(1,H) *h_scale.view(b,1)\n\n sor_curve = torch.stack([r_col, h_col], 2) # BxHx(r,h)\n return sor_curve\n\n\ndef get_random_pitch(b):\n return torch.rand(b) *20 /180*math.pi # 0~20\n\n\ndef get_random_ambient(b):\n return torch.rand(b) *0.4 +0.1 # 0.1~0.5\n\n\ndef get_random_spec_albedo(b):\n return torch.rand(b) *0.9 +0.1 # 0.3~1\n\n\ndef get_random_spec_alpha(b):\n return (torch.rand(b) *13+1)**2 # 1~196\n\n\ndef get_random_sg_lights(b):\n n_sgls = 3\n sgl_dirs = torch.rand(b, n_sgls, 3) *2-1\n\n sgl_dirs[:,:,1] = -sgl_dirs[:,:,1].abs() # upper only\n sgl_dirs[:,:,2] = -sgl_dirs[:,:,2].abs() # front only\n\n sgl_dirs = torch.nn.functional.normalize(sgl_dirs, p=2, dim=2, eps=EPS)\n sgl_lams = torch.rand(b, n_sgls) *30+10\n sgl_Fs = (torch.rand(b, n_sgls) *0.3+0.1) *sgl_lams**0.5\n sg_lights = torch.cat([sgl_dirs, sgl_lams.unsqueeze(2), sgl_Fs.unsqueeze(2)], 2)\n return sg_lights\n\n\ndef get_random_env_map_ambient(b):\n return torch.rand(b) *0.03 # 0~0.1\n\n\ndef random_crop(im_pil, size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333)):\n tfs_crop = torchvision.transforms.RandomResizedCrop(size, scale=scale, ratio=ratio)\n return tfs_crop(im_pil)\n\n\ndef random_color_jitter(im_pil, brightness=0, contrast=0, saturation=0, hue=0):\n tfs_jitter = torchvision.transforms.ColorJitter(brightness, contrast, saturation, hue)\n return tfs_jitter(im_pil)\n\n\ndef generate(cc0_tex_dir, out_dir):\n H = 32\n T = 96\n image_size = 256\n fov = 10\n envmap_n_elev = 32\n envmap_n_azim = 96\n tex_im_h = 256\n tex_im_w = 768\n num_im_per_tex = 5\n\n device = 'cuda:0'\n b = 1\n oriz = 5\n cam_loc = torch.FloatTensor([0,0,-oriz]).to(device)\n lim = math.tan(fov/2/180*math.pi) *oriz\n max_depth = oriz + lim\n min_depth = oriz - lim\n renderer = get_renderer(world_ori=[0,0,oriz], image_size=image_size, fov=fov, fill_back=True)\n sor_faces = get_sor_full_face_idx(H, T).repeat(b,1,1,1,1).to(device) # Bx2x(H-1)xWx3\n tx_size = 8\n tex_uv_grid = get_tex_uv_grid(tx_size, H, T+1).repeat(b,1,1,1,1,1,1).to(device) # Bx2x(H-1)x(W-1)xtxtx2\n\n tex_im_list = sorted(glob(os.path.join(cc0_tex_dir, '**/*Color.jpg'), recursive=True))\n num_tex_im = len(tex_im_list)\n for i, tex_fpath in enumerate(tex_im_list):\n print(f'\\n\\nTex {i}/{num_tex_im}:')\n\n tex_im_pil = Image.open(tex_fpath).convert('RGB')\n\n for j in range(num_im_per_tex):\n tex_im_crop_pil = random_crop(tex_im_pil, size=(tex_im_h, tex_im_w//2), scale=(0.04, 1), ratio=(0.75, 1.3333333333333333))\n tex_im_crop_pil = random_color_jitter(tex_im_crop_pil, brightness=(1.0,1.5), contrast=(1.0,2.0), saturation=0., hue=0.5)\n tex_im_crop = torch.FloatTensor(np.array(tex_im_crop_pil) / 255).to(device)\n tex_im_crop = tex_im_crop.permute(2,0,1).unsqueeze(0)\n tex_im_crop = LDR2HDR(tex_im_crop)\n\n sor_curve = get_random_sor_curve(b,H).to(device) *lim # BxHx2\n sor_vtx = get_sor_vtx(sor_curve, T) # BxHxTx3\n\n ## render rotation pitch rotation\n pitch = get_random_pitch(b).to(device)\n rxyz = torch.stack([pitch, torch.zeros_like(pitch), torch.zeros_like(pitch)], 1)\n posed_sor_vtx = transform_sor(sor_vtx.view(b,-1,3), rxyz, txy=None).view(b,H,T,3)\n\n depth_rendered = renderer.render_depth(posed_sor_vtx.view(b,-1,3), sor_faces.view(b,-1,3)).clamp(min_depth, max_depth)\n mask_rendered = renderer.render_silhouettes(posed_sor_vtx.view(b,-1,3), sor_faces.view(b,-1,3))\n\n normal_map = get_sor_quad_center_normal(posed_sor_vtx) # Bx(H-1)xTx3\n normal_tx_cube = torch.nn.functional.grid_sample(normal_map.permute(0,3,1,2), tex_uv_grid.view(b,-1,tx_size*tx_size,2), mode='bilinear', padding_mode=\"border\", align_corners=False) # Bx3xFxT^2\n normal_tx_cube = normal_tx_cube / (normal_tx_cube**2).sum(1,keepdim=True)**0.5 /2+0.5\n normal_tx_cube = normal_tx_cube.permute(0,2,3,1).view(b,-1,1,tx_size,tx_size,3).repeat(1,1,tx_size,1,1,1) # BxFxtxtxtx3\n normal_rendered = renderer.render_rgb(posed_sor_vtx.view(b,-1,3), sor_faces.view(b,-1,3), normal_tx_cube).clamp(0, 1)\n\n ## sample lighting\n albedo = torch.cat([tex_im_crop, tex_im_crop.flip(3)], 3)\n ambient = get_random_ambient(b).to(device) *0\n spec_albedo = get_random_spec_albedo(b).to(device)\n spec_alpha = get_random_spec_alpha(b).to(device)\n sg_lights = get_random_sg_lights(b).to(device)\n\n posed_sor_vtx_map = get_sor_quad_center_vtx(posed_sor_vtx) # Bx(H-1)xTx3\n env_map = sg_to_env_map(sg_lights, n_elev=envmap_n_elev, n_azim=envmap_n_azim)\n env_map_ambient = get_random_env_map_ambient(b).to(device)\n env_map = env_map + env_map_ambient.view(b,1,1)\n colors, diffuse, specular = envmap_phong_shading(posed_sor_vtx_map, albedo, spec_albedo.view(1,1,1,1), normal_map, cam_loc, ambient, env_map, spec_alpha)\n colors = HDR2LDR(colors)\n colors = colors.clamp(0,1)\n albedo = HDR2LDR(albedo)\n specular = specular * spec_albedo.view(1,1,1,1,1)\n\n im_rendered = render_sor(renderer, posed_sor_vtx, sor_faces, colors, tx_size=tx_size, dim_inside=True).clamp(0, 1)\n albedo_rendered = render_sor(renderer, posed_sor_vtx, sor_faces, albedo, tx_size=tx_size, dim_inside=True).clamp(0, 1)\n diffuse_map = diffuse.sum(1).clamp(0, 1).repeat(1,3,1,1)\n diffuse_rendered = render_sor(renderer, posed_sor_vtx, sor_faces, diffuse_map, tx_size=tx_size).clamp(0, 1)\n specular_map = specular.sum(1).clamp(0, 1).repeat(1,3,1,1)\n specular_rendered = render_sor(renderer, posed_sor_vtx, sor_faces, specular_map, tx_size=tx_size).clamp(0, 1)\n\n results = {}\n results['batch_size'] = b\n results['sor_curve'] = sor_curve.detach().cpu()\n results['pitch'] = pitch.detach().cpu().unsqueeze(1) /math.pi*180\n results['depth_rendered'] = (depth_rendered.detach().cpu().unsqueeze(1).repeat(1,3,1,1) - min_depth) / (max_depth-min_depth)\n results['mask_rendered'] = mask_rendered.detach().cpu().unsqueeze(1).repeat(1,3,1,1)\n\n results['im_rendered'] = im_rendered.detach().cpu()\n results['normal_map'] = normal_map.detach().cpu().permute(0,3,1,2) /2+0.5\n results['normal_rendered'] = normal_rendered.detach().cpu()\n results['albedo_map'] = albedo.detach().cpu()\n results['albedo_rendered'] = albedo_rendered.detach().cpu()\n results['texture_map'] = colors.detach().cpu()\n results['diffuse_map'] = diffuse_map.detach().cpu()\n results['diffuse_rendered'] = diffuse_rendered.detach().cpu()\n results['specular_map'] = specular_map.detach().cpu()\n results['specular_rendered'] = specular_rendered.detach().cpu()\n results['sg_lights'] = sg_lights.detach().cpu()\n results['ambient'] = ambient.detach().cpu().unsqueeze(1)\n results['spec_albedo'] = spec_albedo.detach().cpu().unsqueeze(1)\n results['spec_alpha'] = spec_alpha.detach().cpu().unsqueeze(1)\n results['env_map'] = env_map.clamp(0, 1).detach().cpu().repeat(1,3,1,1)\n results['env_map_ambient'] = env_map_ambient.detach().cpu().unsqueeze(1)\n\n tex_id = '_' + os.path.basename(os.path.dirname(tex_fpath)) + '_%02d' %j\n save_results(out_dir, results, name=tex_id)\n\n\nif __name__ == '__main__':\n cc0_tex_dir = '../cc0_textures/PhotoTexturePBR'\n out_dir = '../syn_curv_sgl5_tex_straight_20220220/rendering'\n\n for split in ['train', 'test']:\n print(f'Generating {split} set...')\n generate(os.path.join(cc0_tex_dir, split), os.path.join(out_dir, split))\n\n os.symlink('test', os.path.join(out_dir, 'val'))\n"
] |
[
[
"torch.zeros",
"torch.nn.functional.normalize",
"torch.cat",
"torch.rand",
"torch.stack",
"numpy.array",
"torch.arange",
"torch.FloatTensor",
"torch.inverse",
"torch.linspace",
"torch.zeros_like",
"torch.meshgrid",
"torch.matmul"
]
] |
boaryang/quantum
|
[
"ef3a34341d997d485a7e43335a8ed61a8e7c6ea6"
] |
[
"tensorflow_quantum/core/serialize/serializer.py"
] |
[
"# Copyright 2020 The TensorFlow Quantum Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"A basic serializer used to serialize/deserialize Cirq circuits for tfq.\"\"\"\n# TODO(pmassey / anyone): determine if this should be kept as globals.\nimport copy\nimport numbers\nimport sympy\nimport numpy as np\n\nimport cirq\nimport cirq.google.api.v2 as v2\nfrom tensorflow_quantum.core.proto import pauli_sum_pb2\n\n# Needed to allow autograph to crawl AST without erroring.\n_CONSTANT_TRUE = lambda x: True\n\n\ndef _round(x):\n return np.round(x, 6) if isinstance(x, float) else x\n\n\ndef _parse_mul(expr):\n \"\"\"Returns the lhs and rhs of a sympy.Mul. This is written\n to prevent autograph from going into sympy library code and having\n conflicts with the @cacheit decorator.\"\"\"\n if len(expr.args) == 1:\n return sympy.S.One, expr.args[0]\n if len(expr.args) == 2:\n return expr.args[0], expr.args[1]\n\n raise ValueError(\"Arithmetic expression outside of simple \"\n \"scalar multiplication is currently not \"\n \"supported. See serializer.py for more \"\n \"information.\")\n\n\ndef _scalar_extractor(x):\n \"\"\"This is a workaround to support symbol scalar multiplication.\n In the future we should likely get rid of this in favor of proper\n expression parsing once cirq supports it. See cirq.op_serializer\n and cirq's program protobuf for details. This is needed for things\n like cirq.rx('alpha').\n \"\"\"\n if not isinstance(x, (numbers.Real, sympy.Expr)):\n raise TypeError(\"Invalid input argument for exponent.\")\n\n if isinstance(x, (numbers.Real, sympy.Symbol)):\n return 1.0\n\n expr = x.evalf()\n if isinstance(expr, sympy.mul.Mul):\n lhs_eval, rhs_eval = _parse_mul(expr)\n\n if isinstance(lhs_eval, sympy.Symbol) and isinstance(\n rhs_eval, (sympy.numbers.Float, sympy.numbers.Integer)):\n # lhs contains symbol rhs contains number.\n return _round(float(rhs_eval))\n\n if isinstance(rhs_eval, sympy.Symbol) and isinstance(\n lhs_eval, (sympy.numbers.Float, sympy.numbers.Integer)):\n # lhs contains number.\n return _round(float(lhs_eval))\n\n raise ValueError(\"Arithmetic expression outside of simple \"\n \"scalar multiplication is currently not \"\n \"supported. See serializer.py for more \"\n \"information.\")\n\n\ndef _symbol_extractor(x):\n \"\"\"This is the second extractor for above.\"\"\"\n if not isinstance(x, (numbers.Real, sympy.Expr)):\n raise TypeError(\"Invalid input argument for exponent.\")\n\n if isinstance(x, numbers.Real):\n return _round(float(x))\n if isinstance(x, sympy.Symbol):\n return x\n\n expr = x.evalf()\n if isinstance(expr, sympy.mul.Mul):\n lhs_eval, rhs_eval = _parse_mul(expr)\n\n if isinstance(lhs_eval, sympy.Symbol) and isinstance(\n rhs_eval, (sympy.numbers.Float, sympy.numbers.Integer)):\n # lhs contains symbol rhs contains number.\n return lhs_eval\n\n if isinstance(rhs_eval, sympy.Symbol) and isinstance(\n lhs_eval, (sympy.numbers.Float, sympy.numbers.Integer)):\n # lhs contains number.\n return rhs_eval\n\n raise ValueError(\"Arithmetic expression outside of simple \"\n \"scalar multiplication is currently not \"\n \"supported. See serializer.py for more \"\n \"information.\")\n\n\ndef _serialize_controls(gate):\n \"\"\"Helper to serialize control qubits if applicable.\"\"\"\n if hasattr(gate, '_tfq_control_qubits'):\n return ','.join(\n v2.qubit_to_proto_id(q) for q in gate._tfq_control_qubits)\n return ''\n\n\ndef _serialize_control_vals(gate):\n \"\"\"Helper to serialize control values if applicable..\"\"\"\n if hasattr(gate, '_tfq_control_values'):\n return ','.join(str(v[0]) for v in gate._tfq_control_values)\n return ''\n\n\nclass DelayedAssignmentGate(cirq.Gate):\n \"\"\"Class to do control qubit assignment before sub_gate qubit assignment.\"\"\"\n\n def __init__(self, gate_callable, control_qubits, control_values):\n self._gate_callable = gate_callable\n self._control_qubits = control_qubits\n self._control_values = control_values\n\n def _qid_shape_(self):\n raise ValueError(\"Called qid_shape on workaround class.\")\n\n # pylint: disable=invalid-name\n def on(self, *qubits):\n \"\"\"Returns gate_callable on qubits controlled by contol_qubits.\"\"\"\n return self._gate_callable(*qubits).controlled_by(\n *self._control_qubits, control_values=self._control_values)\n\n # pylint: enable=invalid-name\n\n\ndef _optional_control_promote(gate, qubits_message, values_message):\n \"\"\"Optionally promote to controlled gate based on serialized control msg.\"\"\"\n if qubits_message == '' and values_message == '':\n return gate\n qbs = [v2.qubit_from_proto_id(qb) for qb in qubits_message.split(',')]\n vals = [int(cv) for cv in values_message.split(',')]\n\n return DelayedAssignmentGate(gate, qbs, vals)\n\n\ndef _depolarize_channel_serializer():\n \"\"\"Make standard serializer for depolarization channel.\"\"\"\n\n args = [\n # cirq channels can't contain symbols.\n cirq.google.SerializingArg(serialized_name=\"p\",\n serialized_type=float,\n op_getter=lambda x: x.gate.p),\n cirq.google.SerializingArg(serialized_name=\"control_qubits\",\n serialized_type=str,\n op_getter=lambda x: ''),\n cirq.google.SerializingArg(serialized_name=\"control_values\",\n serialized_type=str,\n op_getter=lambda x: '')\n ]\n return cirq.google.GateOpSerializer(gate_type=cirq.DepolarizingChannel,\n serialized_gate_id=\"DP\",\n args=args,\n can_serialize_predicate=_CONSTANT_TRUE)\n\n\ndef _depolarize_channel_deserializer():\n \"\"\"Make standard deserializer for depolarization channel.\"\"\"\n\n args = [\n cirq.google.DeserializingArg(serialized_name=\"p\",\n constructor_arg_name=\"p\")\n ]\n return cirq.google.GateOpDeserializer(\n serialized_gate_id=\"DP\",\n gate_constructor=cirq.DepolarizingChannel,\n args=args)\n\n\ndef _eigen_gate_serializer(gate_type, serialized_id):\n \"\"\"Make standard serializer for eigen gates.\"\"\"\n\n args = [\n cirq.google.SerializingArg(\n serialized_name=\"exponent\",\n serialized_type=float,\n op_getter=lambda x: _symbol_extractor(x.gate.exponent)),\n cirq.google.SerializingArg(\n serialized_name=\"exponent_scalar\",\n serialized_type=float,\n op_getter=lambda x: _scalar_extractor(x.gate.exponent)),\n cirq.google.SerializingArg(\n serialized_name=\"global_shift\",\n serialized_type=float,\n op_getter=lambda x: float(x.gate._global_shift)),\n cirq.google.SerializingArg(serialized_name=\"control_qubits\",\n serialized_type=str,\n op_getter=lambda x: _serialize_controls(x)),\n cirq.google.SerializingArg(\n serialized_name=\"control_values\",\n serialized_type=str,\n op_getter=lambda x: _serialize_control_vals(x))\n ]\n return cirq.google.GateOpSerializer(gate_type=gate_type,\n serialized_gate_id=serialized_id,\n args=args,\n can_serialize_predicate=_CONSTANT_TRUE)\n\n\ndef _eigen_gate_deserializer(gate_type, serialized_id):\n \"\"\"Make standard deserializer for eigen gates.\"\"\"\n\n def _scalar_combiner(exponent, global_shift, exponent_scalar,\n control_qubits, control_values):\n \"\"\"This is a workaround to support symbol scalar multiplication.\n In the future we should likely get rid of this in favor of proper\n expression parsing once cirq supports it. See cirq.op_serializer\n and cirq's program protobuf for details. This is needed for things\n like cirq.rx('alpha').\n \"\"\"\n if exponent_scalar == 1.0:\n return _optional_control_promote(\n gate_type(exponent=_round(exponent),\n global_shift=_round(global_shift)), control_qubits,\n control_values)\n return _optional_control_promote(\n gate_type(exponent=_round(exponent) * _round(exponent_scalar),\n global_shift=_round(global_shift)), control_qubits,\n control_values)\n\n args = [\n cirq.google.DeserializingArg(serialized_name=\"exponent\",\n constructor_arg_name=\"exponent\"),\n cirq.google.DeserializingArg(serialized_name=\"global_shift\",\n constructor_arg_name=\"global_shift\"),\n cirq.google.DeserializingArg(serialized_name=\"exponent_scalar\",\n constructor_arg_name=\"exponent_scalar\"),\n cirq.google.DeserializingArg(serialized_name=\"control_qubits\",\n constructor_arg_name=\"control_qubits\"),\n cirq.google.DeserializingArg(serialized_name=\"control_values\",\n constructor_arg_name=\"control_values\")\n ]\n return cirq.google.GateOpDeserializer(serialized_gate_id=serialized_id,\n gate_constructor=_scalar_combiner,\n args=args)\n\n\ndef _fsim_gate_serializer():\n \"\"\"Make standard serializer for fsim gate.\"\"\"\n\n args = [\n cirq.google.SerializingArg(\n serialized_name=\"theta\",\n serialized_type=float,\n op_getter=lambda x: _symbol_extractor(x.gate.theta)),\n cirq.google.SerializingArg(\n serialized_name=\"phi\",\n serialized_type=float,\n op_getter=lambda x: _symbol_extractor(x.gate.phi)),\n cirq.google.SerializingArg(\n serialized_name=\"theta_scalar\",\n serialized_type=float,\n op_getter=lambda x: _scalar_extractor(x.gate.theta)),\n cirq.google.SerializingArg(\n serialized_name=\"phi_scalar\",\n serialized_type=float,\n op_getter=lambda x: _scalar_extractor(x.gate.phi)),\n cirq.google.SerializingArg(serialized_name=\"control_qubits\",\n serialized_type=str,\n op_getter=lambda x: _serialize_controls(x)),\n cirq.google.SerializingArg(\n serialized_name=\"control_values\",\n serialized_type=str,\n op_getter=lambda x: _serialize_control_vals(x))\n ]\n return cirq.google.GateOpSerializer(gate_type=cirq.FSimGate,\n serialized_gate_id=\"FSIM\",\n args=args,\n can_serialize_predicate=_CONSTANT_TRUE)\n\n\ndef _fsim_gate_deserializer():\n \"\"\"Make standard deserializer for fsim gate.\"\"\"\n\n def _scalar_combiner(theta, theta_scalar, phi, phi_scalar, control_qubits,\n control_values):\n \"\"\"This is a workaround to support symbol scalar multiplication.\n See `_eigen_gate_deserializer` for details.\n \"\"\"\n return _optional_control_promote(\n cirq.FSimGate(theta=_round(theta) * _round(theta_scalar),\n phi=_round(phi) * _round(phi_scalar)), control_qubits,\n control_values)\n\n args = [\n cirq.google.DeserializingArg(serialized_name=\"theta\",\n constructor_arg_name=\"theta\"),\n cirq.google.DeserializingArg(serialized_name=\"phi\",\n constructor_arg_name=\"phi\"),\n cirq.google.DeserializingArg(serialized_name=\"theta_scalar\",\n constructor_arg_name=\"theta_scalar\"),\n cirq.google.DeserializingArg(serialized_name=\"phi_scalar\",\n constructor_arg_name=\"phi_scalar\"),\n cirq.google.DeserializingArg(serialized_name=\"control_qubits\",\n constructor_arg_name=\"control_qubits\"),\n cirq.google.DeserializingArg(serialized_name=\"control_values\",\n constructor_arg_name=\"control_values\")\n ]\n return cirq.google.GateOpDeserializer(serialized_gate_id=\"FSIM\",\n gate_constructor=_scalar_combiner,\n args=args)\n\n\ndef _identity_gate_serializer():\n \"\"\"Make a standard serializer for the single qubit identity.\"\"\"\n\n def _identity_check(x):\n if x.gate.num_qubits() != 1:\n raise ValueError(\"Multi-Qubit identity gate not supported.\"\n \"Given: {}. To work around this, use \"\n \"cirq.I.on_each instead.\".format(str(x)))\n return True\n\n # Here `args` is used for two reasons. 1. GateOpSerializer doesn't work well\n # with empty arg lists. 2. It is a nice way to check identity gate size.\n args = [\n cirq.google.SerializingArg(serialized_name=\"unused\",\n serialized_type=bool,\n op_getter=_identity_check),\n cirq.google.SerializingArg(serialized_name=\"control_qubits\",\n serialized_type=str,\n op_getter=lambda x: _serialize_controls(x)),\n cirq.google.SerializingArg(\n serialized_name=\"control_values\",\n serialized_type=str,\n op_getter=lambda x: _serialize_control_vals(x))\n ]\n return cirq.google.GateOpSerializer(gate_type=cirq.IdentityGate,\n serialized_gate_id=\"I\",\n args=args,\n can_serialize_predicate=_CONSTANT_TRUE)\n\n\ndef _identity_gate_deserializer():\n \"\"\"Make a standard deserializer for the single qubit identity.\"\"\"\n args = [\n cirq.google.DeserializingArg(serialized_name=\"unused\",\n constructor_arg_name=\"unused\"),\n cirq.google.DeserializingArg(serialized_name=\"control_qubits\",\n constructor_arg_name=\"control_qubits\"),\n cirq.google.DeserializingArg(serialized_name=\"control_values\",\n constructor_arg_name=\"control_values\")\n ]\n\n def _cirq_i_workaround(unused, control_qubits, control_values):\n return _optional_control_promote(cirq.I, control_qubits, control_values)\n\n return cirq.google.GateOpDeserializer(serialized_gate_id=\"I\",\n gate_constructor=_cirq_i_workaround,\n args=args)\n\n\ndef _phased_eigen_gate_serializer(gate_type, serialized_id):\n \"\"\"Make a standard serializer for phased eigen gates.\"\"\"\n\n args = [\n cirq.google.SerializingArg(\n serialized_name=\"phase_exponent\",\n serialized_type=float,\n op_getter=lambda x: _symbol_extractor(x.gate.phase_exponent)),\n cirq.google.SerializingArg(\n serialized_name=\"phase_exponent_scalar\",\n serialized_type=float,\n op_getter=lambda x: _scalar_extractor(x.gate.phase_exponent)),\n cirq.google.SerializingArg(\n serialized_name=\"exponent\",\n serialized_type=float,\n op_getter=lambda x: _symbol_extractor(x.gate.exponent)),\n cirq.google.SerializingArg(\n serialized_name=\"exponent_scalar\",\n serialized_type=float,\n op_getter=lambda x: _scalar_extractor(x.gate.exponent)),\n cirq.google.SerializingArg(\n serialized_name=\"global_shift\",\n serialized_type=float,\n op_getter=lambda x: float(x.gate.global_shift)),\n cirq.google.SerializingArg(serialized_name=\"control_qubits\",\n serialized_type=str,\n op_getter=lambda x: _serialize_controls(x)),\n cirq.google.SerializingArg(\n serialized_name=\"control_values\",\n serialized_type=str,\n op_getter=lambda x: _serialize_control_vals(x))\n ]\n return cirq.google.GateOpSerializer(gate_type=gate_type,\n serialized_gate_id=serialized_id,\n args=args,\n can_serialize_predicate=_CONSTANT_TRUE)\n\n\ndef _phased_eigen_gate_deserializer(gate_type, serialized_id):\n \"\"\"Make a standard deserializer for phased eigen gates.\"\"\"\n\n def _scalar_combiner(exponent, global_shift, exponent_scalar,\n phase_exponent, phase_exponent_scalar, control_qubits,\n control_values):\n \"\"\"This is a workaround to support symbol scalar multiplication.\n In the future we should likely get rid of this in favor of proper\n expression parsing once cirq supports it. See cirq.op_serializer\n and cirq's program protobuf for details. This is needed for things\n like cirq.rx('alpha').\n \"\"\"\n exponent = _round(exponent)\n phase_exponent = _round(phase_exponent)\n exponent = exponent if exponent_scalar == 1.0 \\\n else exponent * _round(exponent_scalar)\n phase_exponent = phase_exponent if phase_exponent_scalar == 1.0 \\\n else phase_exponent * _round(phase_exponent_scalar)\n if global_shift != 0:\n # needed in case this specific phasedeigengate doesn't\n # have a global_phase in constructor.\n return _optional_control_promote(\n gate_type(exponent=exponent,\n global_shift=_round(global_shift),\n phase_exponent=phase_exponent), control_qubits,\n control_values)\n return _optional_control_promote(\n gate_type(exponent=exponent, phase_exponent=phase_exponent),\n control_qubits, control_values)\n\n args = [\n cirq.google.DeserializingArg(serialized_name=\"phase_exponent\",\n constructor_arg_name=\"phase_exponent\"),\n cirq.google.DeserializingArg(\n serialized_name=\"phase_exponent_scalar\",\n constructor_arg_name=\"phase_exponent_scalar\"),\n cirq.google.DeserializingArg(serialized_name=\"exponent\",\n constructor_arg_name=\"exponent\"),\n cirq.google.DeserializingArg(serialized_name=\"exponent_scalar\",\n constructor_arg_name=\"exponent_scalar\"),\n cirq.google.DeserializingArg(serialized_name=\"global_shift\",\n constructor_arg_name=\"global_shift\"),\n cirq.google.DeserializingArg(serialized_name=\"control_qubits\",\n constructor_arg_name=\"control_qubits\"),\n cirq.google.DeserializingArg(serialized_name=\"control_values\",\n constructor_arg_name=\"control_values\")\n ]\n return cirq.google.GateOpDeserializer(serialized_gate_id=serialized_id,\n gate_constructor=_scalar_combiner,\n args=args)\n\n\nEIGEN_GATES_DICT = {\n cirq.XPowGate: \"XP\",\n cirq.XXPowGate: \"XXP\",\n cirq.YPowGate: \"YP\",\n cirq.YYPowGate: \"YYP\",\n cirq.ZPowGate: \"ZP\",\n cirq.ZZPowGate: \"ZZP\",\n cirq.HPowGate: \"HP\",\n cirq.CZPowGate: \"CZP\",\n cirq.CNotPowGate: \"CNP\",\n cirq.SwapPowGate: \"SP\",\n cirq.ISwapPowGate: \"ISP\",\n}\n\nPHASED_EIGEN_GATES_DICT = {\n cirq.PhasedXPowGate: \"PXP\",\n cirq.PhasedISwapPowGate: \"PISP\",\n}\n\nSERIALIZERS = [\n _eigen_gate_serializer(g, g_name) for g, g_name in EIGEN_GATES_DICT.items()\n] + [\n _fsim_gate_serializer(),\n] + [\n _identity_gate_serializer(),\n] + [\n _phased_eigen_gate_serializer(g, g_name)\n for g, g_name in PHASED_EIGEN_GATES_DICT.items()\n] + [_depolarize_channel_serializer()]\n\nDESERIALIZERS = [\n _eigen_gate_deserializer(g, g_name)\n for g, g_name in EIGEN_GATES_DICT.items()\n] + [\n _fsim_gate_deserializer(),\n] + [\n _identity_gate_deserializer(),\n] + [\n _phased_eigen_gate_deserializer(g, g_name)\n for g, g_name in PHASED_EIGEN_GATES_DICT.items()\n] + [_depolarize_channel_deserializer()]\n\nSERIALIZER = cirq.google.SerializableGateSet(gate_set_name=\"tfq_gate_set\",\n serializers=SERIALIZERS,\n deserializers=DESERIALIZERS)\n\n\ndef serialize_circuit(circuit_inp):\n \"\"\"Returns a `cirq.Program` proto representing the `cirq.Circuit`.\n\n Note that the circuit must use gates valid in the tfq_gate_set.\n Currently we only support scalar multiplication of symbols and\n no other more complex arithmetic expressions. This means\n we can support things like X**(3*alpha), and Rx(alpha). Because\n we use the `cirq.Program` proto, we only support `cirq.GridQubit` instances\n during serialization of circuits.\n\n Note: once serialized terminal measurements are removed.\n\n Args:\n circuit_inp: A `cirq.Circuit`.\n\n Returns:\n A `cirq.google.api.v2.Program` proto.\n \"\"\"\n circuit = copy.deepcopy(circuit_inp)\n if not isinstance(circuit, cirq.Circuit):\n raise TypeError(\"serialize requires cirq.Circuit objects.\"\n \" Given: \" + str(type(circuit)))\n\n # This code is intentionally written to avoid using cirq functions\n # as this get analyzed by tensorflow-autograph.\n\n # Gives a map from moment index to measure qubits in moment\n measured_moments = dict()\n\n # Tracks qubits that have been measured already.\n all_measured_qubits = set()\n for i, moment in enumerate(circuit.moments):\n measured_qubits = set()\n for op in moment:\n for qubit in op.qubits:\n if not isinstance(qubit, cirq.GridQubit):\n raise ValueError(\n \"Attempted to serialize circuit that don't use \"\n \"only cirq.GridQubits.\")\n\n if isinstance(op.gate, cirq.MeasurementGate):\n for qubit in op.qubits:\n if qubit in all_measured_qubits:\n raise ValueError(\"Serialization of circuit failed. \"\n \"Circuits with non-terminal \"\n \"measurement operations are not \"\n \"supported.\")\n measured_qubits.add(qubit)\n all_measured_qubits.add(qubit)\n\n if len(measured_qubits) > 0:\n measured_moments[i] = measured_qubits\n\n # Remove terminal measurements.\n for moment_ind in measured_moments:\n old_moment = circuit[moment_ind]\n measured_qubits = measured_moments[moment_ind]\n new_moment = cirq.Moment(\n filter(lambda x: not any(y in measured_qubits for y in x.qubits),\n old_moment.operations))\n circuit[moment_ind] = new_moment\n\n # Demote cirq.controlled_operations (controlled gates) to their sub_gate\n # types with _tfq_control_qubits and _tfq_control_values fields so that\n # the gates can still get picked up by the serializer. There would be no way\n # to discern controlledgates from one another otherwise. This\n # \"momentary demotion\" occurs with the help of the DelayedAssignmentGate.\n for i, moment in enumerate(circuit):\n controlled_ops = [\n op for op in moment if isinstance(op, cirq.ControlledOperation)\n ]\n new_ops = dict()\n for op in controlled_ops:\n tfq_compatible = op.sub_operation\n tfq_compatible._tfq_control_qubits = op.controls\n tfq_compatible._tfq_control_values = op.control_values\n new_ops[op.qubits] = tfq_compatible\n\n circuit[i] = cirq.Moment(\n new_ops[op.qubits] if op.qubits in new_ops else op for op in moment)\n\n return SERIALIZER.serialize(circuit)\n\n\ndef deserialize_circuit(proto):\n \"\"\"Constructs a `cirq.Circuit` from a `cirq.Program` proto.\n\n Note that the proto must use gates valid in the tfq_gate_set.\n\n Args:\n proto: A `cirq.google.api.v2.Program` proto\n\n Returns:\n A `cirq.Circuit`.\n \"\"\"\n if not isinstance(proto, cirq.google.api.v2.program_pb2.Program):\n raise TypeError(\"deserialize requires \"\n \"cirq.google.api.v2.program_pb2.Program object.\"\n \" Given: \" + str(type(proto)))\n\n return SERIALIZER.deserialize(proto)\n\n\ndef serialize_paulisum(paulisum):\n \"\"\"Constructs a pauli_sum proto from `cirq.PauliSum` or `cirq.PauliString`.\n\n Args:\n paulisum: A `cirq.PauliSum` object.\n\n Returns:\n A pauli_sum proto object.\n \"\"\"\n if isinstance(paulisum, cirq.PauliString):\n paulisum = cirq.PauliSum.from_pauli_strings(paulisum)\n\n if not isinstance(paulisum, cirq.PauliSum):\n raise TypeError(\"serialize requires a cirq.PauliSum object.\"\n \" Given: \" + str(type(paulisum)))\n\n if any(not isinstance(qubit, cirq.GridQubit) for qubit in paulisum.qubits):\n raise ValueError(\"Attempted to serialize a paulisum that doesn't use \"\n \"only cirq.GridQubits.\")\n\n paulisum_proto = pauli_sum_pb2.PauliSum()\n for term in paulisum:\n pauliterm_proto = pauli_sum_pb2.PauliTerm()\n\n pauliterm_proto.coefficient_real = term.coefficient.real\n pauliterm_proto.coefficient_imag = term.coefficient.imag\n for t in sorted(term.items()): # sort to keep qubits ordered.\n pauliterm_proto.paulis.add(\n qubit_id=v2.qubit_to_proto_id(t[0]),\n pauli_type=str(t[1]),\n )\n paulisum_proto.terms.extend([pauliterm_proto])\n\n return paulisum_proto\n\n\ndef deserialize_paulisum(proto):\n \"\"\"Constructs a `cirq.PauliSum` from pauli_sum proto.\n\n Args:\n proto: A pauli_sum proto object.\n\n Returns:\n A `cirq.PauliSum` object.\n \"\"\"\n if not isinstance(proto, pauli_sum_pb2.PauliSum):\n raise TypeError(\"deserialize requires a pauli_sum_pb2 object.\"\n \" Given: \" + str(type(proto)))\n\n res = cirq.PauliSum()\n for term_proto in proto.terms:\n coef = float(_round(term_proto.coefficient_real)) + \\\n 1.0j * float(_round(term_proto.coefficient_imag))\n term = coef * cirq.PauliString()\n for pauli_qubit_pair in term_proto.paulis:\n op = _process_pauli_type(pauli_qubit_pair.pauli_type)\n term *= op(v2.grid_qubit_from_proto_id(pauli_qubit_pair.qubit_id))\n res += term\n\n return res\n\n\ndef _process_pauli_type(char):\n if char == 'Z':\n return cirq.Z\n if char == 'X':\n return cirq.X\n if char == 'Y':\n return cirq.Y\n raise ValueError(\"Invalid pauli type.\")\n"
] |
[
[
"numpy.round"
]
] |
alazarchuk/scipy
|
[
"7124fc982ea9b0ea961c65db550c0703abcb9bfd"
] |
[
"scipy/signal/tests/test_windows.py"
] |
[
"import pickle\n\nimport numpy as np\nfrom numpy import array\nfrom numpy.testing import (assert_array_almost_equal, assert_array_equal,\n assert_allclose,\n assert_equal, assert_, assert_array_less,\n suppress_warnings)\nfrom pytest import raises as assert_raises\n\nfrom scipy.fft import fft\nfrom scipy.signal import windows, get_window, resample, hann as dep_hann\n\n\nwindow_funcs = [\n ('boxcar', ()),\n ('triang', ()),\n ('parzen', ()),\n ('bohman', ()),\n ('blackman', ()),\n ('nuttall', ()),\n ('blackmanharris', ()),\n ('flattop', ()),\n ('bartlett', ()),\n ('hanning', ()),\n ('barthann', ()),\n ('hamming', ()),\n ('kaiser', (1,)),\n ('dpss', (2,)),\n ('gaussian', (0.5,)),\n ('general_gaussian', (1.5, 2)),\n ('chebwin', (1,)),\n ('cosine', ()),\n ('hann', ()),\n ('exponential', ()),\n ('tukey', (0.5,)),\n ]\n\n\nclass TestBartHann(object):\n\n def test_basic(self):\n assert_allclose(windows.barthann(6, sym=True),\n [0, 0.35857354213752, 0.8794264578624801,\n 0.8794264578624801, 0.3585735421375199, 0])\n assert_allclose(windows.barthann(7),\n [0, 0.27, 0.73, 1.0, 0.73, 0.27, 0])\n assert_allclose(windows.barthann(6, False),\n [0, 0.27, 0.73, 1.0, 0.73, 0.27])\n\n\nclass TestBartlett(object):\n\n def test_basic(self):\n assert_allclose(windows.bartlett(6), [0, 0.4, 0.8, 0.8, 0.4, 0])\n assert_allclose(windows.bartlett(7), [0, 1/3, 2/3, 1.0, 2/3, 1/3, 0])\n assert_allclose(windows.bartlett(6, False),\n [0, 1/3, 2/3, 1.0, 2/3, 1/3])\n\n\nclass TestBlackman(object):\n\n def test_basic(self):\n assert_allclose(windows.blackman(6, sym=False),\n [0, 0.13, 0.63, 1.0, 0.63, 0.13], atol=1e-14)\n assert_allclose(windows.blackman(7, sym=False),\n [0, 0.09045342435412804, 0.4591829575459636,\n 0.9203636180999081, 0.9203636180999081,\n 0.4591829575459636, 0.09045342435412804], atol=1e-8)\n assert_allclose(windows.blackman(6),\n [0, 0.2007701432625305, 0.8492298567374694,\n 0.8492298567374694, 0.2007701432625305, 0],\n atol=1e-14)\n assert_allclose(windows.blackman(7, True),\n [0, 0.13, 0.63, 1.0, 0.63, 0.13, 0], atol=1e-14)\n\n\nclass TestBlackmanHarris(object):\n\n def test_basic(self):\n assert_allclose(windows.blackmanharris(6, False),\n [6.0e-05, 0.055645, 0.520575, 1.0, 0.520575, 0.055645])\n assert_allclose(windows.blackmanharris(7, sym=False),\n [6.0e-05, 0.03339172347815117, 0.332833504298565,\n 0.8893697722232837, 0.8893697722232838,\n 0.3328335042985652, 0.03339172347815122])\n assert_allclose(windows.blackmanharris(6),\n [6.0e-05, 0.1030114893456638, 0.7938335106543362,\n 0.7938335106543364, 0.1030114893456638, 6.0e-05])\n assert_allclose(windows.blackmanharris(7, sym=True),\n [6.0e-05, 0.055645, 0.520575, 1.0, 0.520575, 0.055645,\n 6.0e-05])\n\n\nclass TestBohman(object):\n\n def test_basic(self):\n assert_allclose(windows.bohman(6),\n [0, 0.1791238937062839, 0.8343114522576858,\n 0.8343114522576858, 0.1791238937062838, 0])\n assert_allclose(windows.bohman(7, sym=True),\n [0, 0.1089977810442293, 0.6089977810442293, 1.0,\n 0.6089977810442295, 0.1089977810442293, 0])\n assert_allclose(windows.bohman(6, False),\n [0, 0.1089977810442293, 0.6089977810442293, 1.0,\n 0.6089977810442295, 0.1089977810442293])\n\n\nclass TestBoxcar(object):\n\n def test_basic(self):\n assert_allclose(windows.boxcar(6), [1, 1, 1, 1, 1, 1])\n assert_allclose(windows.boxcar(7), [1, 1, 1, 1, 1, 1, 1])\n assert_allclose(windows.boxcar(6, False), [1, 1, 1, 1, 1, 1])\n\n\ncheb_odd_true = array([0.200938, 0.107729, 0.134941, 0.165348,\n 0.198891, 0.235450, 0.274846, 0.316836,\n 0.361119, 0.407338, 0.455079, 0.503883,\n 0.553248, 0.602637, 0.651489, 0.699227,\n 0.745266, 0.789028, 0.829947, 0.867485,\n 0.901138, 0.930448, 0.955010, 0.974482,\n 0.988591, 0.997138, 1.000000, 0.997138,\n 0.988591, 0.974482, 0.955010, 0.930448,\n 0.901138, 0.867485, 0.829947, 0.789028,\n 0.745266, 0.699227, 0.651489, 0.602637,\n 0.553248, 0.503883, 0.455079, 0.407338,\n 0.361119, 0.316836, 0.274846, 0.235450,\n 0.198891, 0.165348, 0.134941, 0.107729,\n 0.200938])\n\ncheb_even_true = array([0.203894, 0.107279, 0.133904,\n 0.163608, 0.196338, 0.231986,\n 0.270385, 0.311313, 0.354493,\n 0.399594, 0.446233, 0.493983,\n 0.542378, 0.590916, 0.639071,\n 0.686302, 0.732055, 0.775783,\n 0.816944, 0.855021, 0.889525,\n 0.920006, 0.946060, 0.967339,\n 0.983557, 0.994494, 1.000000,\n 1.000000, 0.994494, 0.983557,\n 0.967339, 0.946060, 0.920006,\n 0.889525, 0.855021, 0.816944,\n 0.775783, 0.732055, 0.686302,\n 0.639071, 0.590916, 0.542378,\n 0.493983, 0.446233, 0.399594,\n 0.354493, 0.311313, 0.270385,\n 0.231986, 0.196338, 0.163608,\n 0.133904, 0.107279, 0.203894])\n\n\nclass TestChebWin(object):\n\n def test_basic(self):\n with suppress_warnings() as sup:\n sup.filter(UserWarning, \"This window is not suitable\")\n assert_allclose(windows.chebwin(6, 100),\n [0.1046401879356917, 0.5075781475823447, 1.0, 1.0,\n 0.5075781475823447, 0.1046401879356917])\n assert_allclose(windows.chebwin(7, 100),\n [0.05650405062850233, 0.316608530648474,\n 0.7601208123539079, 1.0, 0.7601208123539079,\n 0.316608530648474, 0.05650405062850233])\n assert_allclose(windows.chebwin(6, 10),\n [1.0, 0.6071201674458373, 0.6808391469897297,\n 0.6808391469897297, 0.6071201674458373, 1.0])\n assert_allclose(windows.chebwin(7, 10),\n [1.0, 0.5190521247588651, 0.5864059018130382,\n 0.6101519801307441, 0.5864059018130382,\n 0.5190521247588651, 1.0])\n assert_allclose(windows.chebwin(6, 10, False),\n [1.0, 0.5190521247588651, 0.5864059018130382,\n 0.6101519801307441, 0.5864059018130382,\n 0.5190521247588651])\n\n def test_cheb_odd_high_attenuation(self):\n with suppress_warnings() as sup:\n sup.filter(UserWarning, \"This window is not suitable\")\n cheb_odd = windows.chebwin(53, at=-40)\n assert_array_almost_equal(cheb_odd, cheb_odd_true, decimal=4)\n\n def test_cheb_even_high_attenuation(self):\n with suppress_warnings() as sup:\n sup.filter(UserWarning, \"This window is not suitable\")\n cheb_even = windows.chebwin(54, at=40)\n assert_array_almost_equal(cheb_even, cheb_even_true, decimal=4)\n\n def test_cheb_odd_low_attenuation(self):\n cheb_odd_low_at_true = array([1.000000, 0.519052, 0.586405,\n 0.610151, 0.586405, 0.519052,\n 1.000000])\n with suppress_warnings() as sup:\n sup.filter(UserWarning, \"This window is not suitable\")\n cheb_odd = windows.chebwin(7, at=10)\n assert_array_almost_equal(cheb_odd, cheb_odd_low_at_true, decimal=4)\n\n def test_cheb_even_low_attenuation(self):\n cheb_even_low_at_true = array([1.000000, 0.451924, 0.51027,\n 0.541338, 0.541338, 0.51027,\n 0.451924, 1.000000])\n with suppress_warnings() as sup:\n sup.filter(UserWarning, \"This window is not suitable\")\n cheb_even = windows.chebwin(8, at=-10)\n assert_array_almost_equal(cheb_even, cheb_even_low_at_true, decimal=4)\n\n\nexponential_data = {\n (4, None, 0.2, False):\n array([4.53999297624848542e-05,\n 6.73794699908546700e-03, 1.00000000000000000e+00,\n 6.73794699908546700e-03]),\n (4, None, 0.2, True): array([0.00055308437014783, 0.0820849986238988,\n 0.0820849986238988, 0.00055308437014783]),\n (4, None, 1.0, False): array([0.1353352832366127, 0.36787944117144233, 1.,\n 0.36787944117144233]),\n (4, None, 1.0, True): array([0.22313016014842982, 0.60653065971263342,\n 0.60653065971263342, 0.22313016014842982]),\n (4, 2, 0.2, False):\n array([4.53999297624848542e-05, 6.73794699908546700e-03,\n 1.00000000000000000e+00, 6.73794699908546700e-03]),\n (4, 2, 0.2, True): None,\n (4, 2, 1.0, False): array([0.1353352832366127, 0.36787944117144233, 1.,\n 0.36787944117144233]),\n (4, 2, 1.0, True): None,\n (5, None, 0.2, True):\n array([4.53999297624848542e-05,\n 6.73794699908546700e-03, 1.00000000000000000e+00,\n 6.73794699908546700e-03, 4.53999297624848542e-05]),\n (5, None, 1.0, True): array([0.1353352832366127, 0.36787944117144233, 1.,\n 0.36787944117144233, 0.1353352832366127]),\n (5, 2, 0.2, True): None,\n (5, 2, 1.0, True): None\n}\n\n\ndef test_exponential():\n for k, v in exponential_data.items():\n if v is None:\n assert_raises(ValueError, windows.exponential, *k)\n else:\n win = windows.exponential(*k)\n assert_allclose(win, v, rtol=1e-14)\n\n\nclass TestFlatTop(object):\n\n def test_basic(self):\n assert_allclose(windows.flattop(6, sym=False),\n [-0.000421051, -0.051263156, 0.19821053, 1.0,\n 0.19821053, -0.051263156])\n assert_allclose(windows.flattop(7, sym=False),\n [-0.000421051, -0.03684078115492348,\n 0.01070371671615342, 0.7808739149387698,\n 0.7808739149387698, 0.01070371671615342,\n -0.03684078115492348])\n assert_allclose(windows.flattop(6),\n [-0.000421051, -0.0677142520762119, 0.6068721525762117,\n 0.6068721525762117, -0.0677142520762119,\n -0.000421051])\n assert_allclose(windows.flattop(7, True),\n [-0.000421051, -0.051263156, 0.19821053, 1.0,\n 0.19821053, -0.051263156, -0.000421051])\n\n\nclass TestGaussian(object):\n\n def test_basic(self):\n assert_allclose(windows.gaussian(6, 1.0),\n [0.04393693362340742, 0.3246524673583497,\n 0.8824969025845955, 0.8824969025845955,\n 0.3246524673583497, 0.04393693362340742])\n assert_allclose(windows.gaussian(7, 1.2),\n [0.04393693362340742, 0.2493522087772962,\n 0.7066482778577162, 1.0, 0.7066482778577162,\n 0.2493522087772962, 0.04393693362340742])\n assert_allclose(windows.gaussian(7, 3),\n [0.6065306597126334, 0.8007374029168081,\n 0.9459594689067654, 1.0, 0.9459594689067654,\n 0.8007374029168081, 0.6065306597126334])\n assert_allclose(windows.gaussian(6, 3, False),\n [0.6065306597126334, 0.8007374029168081,\n 0.9459594689067654, 1.0, 0.9459594689067654,\n 0.8007374029168081])\n\n\nclass TestGeneralCosine(object):\n\n def test_basic(self):\n assert_allclose(windows.general_cosine(5, [0.5, 0.3, 0.2]),\n [0.4, 0.3, 1, 0.3, 0.4])\n assert_allclose(windows.general_cosine(4, [0.5, 0.3, 0.2], sym=False),\n [0.4, 0.3, 1, 0.3])\n\nclass TestGeneralHamming(object):\n\n def test_basic(self):\n assert_allclose(windows.general_hamming(5, 0.7),\n [0.4, 0.7, 1.0, 0.7, 0.4])\n assert_allclose(windows.general_hamming(5, 0.75, sym=False),\n [0.5, 0.6727457514, 0.9522542486,\n 0.9522542486, 0.6727457514])\n assert_allclose(windows.general_hamming(6, 0.75, sym=True),\n [0.5, 0.6727457514, 0.9522542486,\n 0.9522542486, 0.6727457514, 0.5])\n\n\nclass TestHamming(object):\n\n def test_basic(self):\n assert_allclose(windows.hamming(6, False),\n [0.08, 0.31, 0.77, 1.0, 0.77, 0.31])\n assert_allclose(windows.hamming(7, sym=False),\n [0.08, 0.2531946911449826, 0.6423596296199047,\n 0.9544456792351128, 0.9544456792351128,\n 0.6423596296199047, 0.2531946911449826])\n assert_allclose(windows.hamming(6),\n [0.08, 0.3978521825875242, 0.9121478174124757,\n 0.9121478174124757, 0.3978521825875242, 0.08])\n assert_allclose(windows.hamming(7, sym=True),\n [0.08, 0.31, 0.77, 1.0, 0.77, 0.31, 0.08])\n\n\nclass TestHann(object):\n\n def test_basic(self):\n assert_allclose(windows.hann(6, sym=False),\n [0, 0.25, 0.75, 1.0, 0.75, 0.25])\n assert_allclose(windows.hann(7, sym=False),\n [0, 0.1882550990706332, 0.6112604669781572,\n 0.9504844339512095, 0.9504844339512095,\n 0.6112604669781572, 0.1882550990706332])\n assert_allclose(windows.hann(6, True),\n [0, 0.3454915028125263, 0.9045084971874737,\n 0.9045084971874737, 0.3454915028125263, 0])\n assert_allclose(windows.hann(7),\n [0, 0.25, 0.75, 1.0, 0.75, 0.25, 0])\n\n\nclass TestKaiser(object):\n\n def test_basic(self):\n assert_allclose(windows.kaiser(6, 0.5),\n [0.9403061933191572, 0.9782962393705389,\n 0.9975765035372042, 0.9975765035372042,\n 0.9782962393705389, 0.9403061933191572])\n assert_allclose(windows.kaiser(7, 0.5),\n [0.9403061933191572, 0.9732402256999829,\n 0.9932754654413773, 1.0, 0.9932754654413773,\n 0.9732402256999829, 0.9403061933191572])\n assert_allclose(windows.kaiser(6, 2.7),\n [0.2603047507678832, 0.6648106293528054,\n 0.9582099802511439, 0.9582099802511439,\n 0.6648106293528054, 0.2603047507678832])\n assert_allclose(windows.kaiser(7, 2.7),\n [0.2603047507678832, 0.5985765418119844,\n 0.8868495172060835, 1.0, 0.8868495172060835,\n 0.5985765418119844, 0.2603047507678832])\n assert_allclose(windows.kaiser(6, 2.7, False),\n [0.2603047507678832, 0.5985765418119844,\n 0.8868495172060835, 1.0, 0.8868495172060835,\n 0.5985765418119844])\n\n\nclass TestNuttall(object):\n\n def test_basic(self):\n assert_allclose(windows.nuttall(6, sym=False),\n [0.0003628, 0.0613345, 0.5292298, 1.0, 0.5292298,\n 0.0613345])\n assert_allclose(windows.nuttall(7, sym=False),\n [0.0003628, 0.03777576895352025, 0.3427276199688195,\n 0.8918518610776603, 0.8918518610776603,\n 0.3427276199688196, 0.0377757689535203])\n assert_allclose(windows.nuttall(6),\n [0.0003628, 0.1105152530498718, 0.7982580969501282,\n 0.7982580969501283, 0.1105152530498719, 0.0003628])\n assert_allclose(windows.nuttall(7, True),\n [0.0003628, 0.0613345, 0.5292298, 1.0, 0.5292298,\n 0.0613345, 0.0003628])\n\n\nclass TestParzen(object):\n\n def test_basic(self):\n assert_allclose(windows.parzen(6),\n [0.009259259259259254, 0.25, 0.8611111111111112,\n 0.8611111111111112, 0.25, 0.009259259259259254])\n assert_allclose(windows.parzen(7, sym=True),\n [0.00583090379008747, 0.1574344023323616,\n 0.6501457725947521, 1.0, 0.6501457725947521,\n 0.1574344023323616, 0.00583090379008747])\n assert_allclose(windows.parzen(6, False),\n [0.00583090379008747, 0.1574344023323616,\n 0.6501457725947521, 1.0, 0.6501457725947521,\n 0.1574344023323616])\n\n\nclass TestTriang(object):\n\n def test_basic(self):\n\n assert_allclose(windows.triang(6, True),\n [1/6, 1/2, 5/6, 5/6, 1/2, 1/6])\n assert_allclose(windows.triang(7),\n [1/4, 1/2, 3/4, 1, 3/4, 1/2, 1/4])\n assert_allclose(windows.triang(6, sym=False),\n [1/4, 1/2, 3/4, 1, 3/4, 1/2])\n\n\ntukey_data = {\n (4, 0.5, True): array([0.0, 1.0, 1.0, 0.0]),\n (4, 0.9, True): array([0.0, 0.84312081893436686,\n 0.84312081893436686, 0.0]),\n (4, 1.0, True): array([0.0, 0.75, 0.75, 0.0]),\n (4, 0.5, False): array([0.0, 1.0, 1.0, 1.0]),\n (4, 0.9, False): array([0.0, 0.58682408883346526,\n 1.0, 0.58682408883346526]),\n (4, 1.0, False): array([0.0, 0.5, 1.0, 0.5]),\n (5, 0.0, True): array([1.0, 1.0, 1.0, 1.0, 1.0]),\n (5, 0.8, True): array([0.0, 0.69134171618254492,\n 1.0, 0.69134171618254492, 0.0]),\n (5, 1.0, True): array([0.0, 0.5, 1.0, 0.5, 0.0]),\n\n (6, 0): [1, 1, 1, 1, 1, 1],\n (7, 0): [1, 1, 1, 1, 1, 1, 1],\n (6, .25): [0, 1, 1, 1, 1, 0],\n (7, .25): [0, 1, 1, 1, 1, 1, 0],\n (6,): [0, 0.9045084971874737, 1.0, 1.0, 0.9045084971874735, 0],\n (7,): [0, 0.75, 1.0, 1.0, 1.0, 0.75, 0],\n (6, .75): [0, 0.5522642316338269, 1.0, 1.0, 0.5522642316338267, 0],\n (7, .75): [0, 0.4131759111665348, 0.9698463103929542, 1.0,\n 0.9698463103929542, 0.4131759111665347, 0],\n (6, 1): [0, 0.3454915028125263, 0.9045084971874737, 0.9045084971874737,\n 0.3454915028125263, 0],\n (7, 1): [0, 0.25, 0.75, 1.0, 0.75, 0.25, 0],\n}\n\n\nclass TestTukey(object):\n\n def test_basic(self):\n # Test against hardcoded data\n for k, v in tukey_data.items():\n if v is None:\n assert_raises(ValueError, windows.tukey, *k)\n else:\n win = windows.tukey(*k)\n assert_allclose(win, v, rtol=1e-14)\n\n def test_extremes(self):\n # Test extremes of alpha correspond to boxcar and hann\n tuk0 = windows.tukey(100, 0)\n box0 = windows.boxcar(100)\n assert_array_almost_equal(tuk0, box0)\n\n tuk1 = windows.tukey(100, 1)\n han1 = windows.hann(100)\n assert_array_almost_equal(tuk1, han1)\n\n\ndpss_data = {\n # All values from MATLAB:\n # * taper[1] of (3, 1.4, 3) sign-flipped\n # * taper[3] of (5, 1.5, 5) sign-flipped\n (4, 0.1, 2): ([[0.497943898, 0.502047681, 0.502047681, 0.497943898], [0.670487993, 0.224601537, -0.224601537, -0.670487993]], [0.197961815, 0.002035474]), # noqa\n (3, 1.4, 3): ([[0.410233151, 0.814504464, 0.410233151], [0.707106781, 0.0, -0.707106781], [0.575941629, -0.580157287, 0.575941629]], [0.999998093, 0.998067480, 0.801934426]), # noqa\n (5, 1.5, 5): ([[0.1745071052, 0.4956749177, 0.669109327, 0.495674917, 0.174507105], [0.4399493348, 0.553574369, 0.0, -0.553574369, -0.439949334], [0.631452756, 0.073280238, -0.437943884, 0.073280238, 0.631452756], [0.553574369, -0.439949334, 0.0, 0.439949334, -0.553574369], [0.266110290, -0.498935248, 0.600414741, -0.498935248, 0.266110290147157]], [0.999728571, 0.983706916, 0.768457889, 0.234159338, 0.013947282907567]), # noqa: E501\n (100, 2, 4): ([[0.0030914414, 0.0041266922, 0.005315076, 0.006665149, 0.008184854, 0.0098814158, 0.011761239, 0.013829809, 0.016091597, 0.018549973, 0.02120712, 0.02406396, 0.027120092, 0.030373728, 0.033821651, 0.037459181, 0.041280145, 0.045276872, 0.049440192, 0.053759447, 0.058222524, 0.062815894, 0.067524661, 0.072332638, 0.077222418, 0.082175473, 0.087172252, 0.092192299, 0.097214376, 0.1022166, 0.10717657, 0.11207154, 0.11687856, 0.12157463, 0.12613686, 0.13054266, 0.13476986, 0.13879691, 0.14260302, 0.14616832, 0.14947401, 0.1525025, 0.15523755, 0.15766438, 0.15976981, 0.16154233, 0.16297223, 0.16405162, 0.16477455, 0.16513702, 0.16513702, 0.16477455, 0.16405162, 0.16297223, 0.16154233, 0.15976981, 0.15766438, 0.15523755, 0.1525025, 0.14947401, 0.14616832, 0.14260302, 0.13879691, 0.13476986, 0.13054266, 0.12613686, 0.12157463, 0.11687856, 0.11207154, 0.10717657, 0.1022166, 0.097214376, 0.092192299, 0.087172252, 0.082175473, 0.077222418, 0.072332638, 0.067524661, 0.062815894, 0.058222524, 0.053759447, 0.049440192, 0.045276872, 0.041280145, 0.037459181, 0.033821651, 0.030373728, 0.027120092, 0.02406396, 0.02120712, 0.018549973, 0.016091597, 0.013829809, 0.011761239, 0.0098814158, 0.008184854, 0.006665149, 0.005315076, 0.0041266922, 0.0030914414], [0.018064449, 0.022040342, 0.026325013, 0.030905288, 0.035764398, 0.040881982, 0.046234148, 0.051793558, 0.057529559, 0.063408356, 0.069393216, 0.075444716, 0.081521022, 0.087578202, 0.093570567, 0.099451049, 0.10517159, 0.11068356, 0.11593818, 0.12088699, 0.12548227, 0.12967752, 0.1334279, 0.13669069, 0.13942569, 0.1415957, 0.14316686, 0.14410905, 0.14439626, 0.14400686, 0.14292389, 0.1411353, 0.13863416, 0.13541876, 0.13149274, 0.12686516, 0.12155045, 0.1155684, 0.10894403, 0.10170748, 0.093893752, 0.08554251, 0.076697768, 0.067407559, 0.057723559, 0.04770068, 0.037396627, 0.026871428, 0.016186944, 0.0054063557, -0.0054063557, -0.016186944, -0.026871428, -0.037396627, -0.04770068, -0.057723559, -0.067407559, -0.076697768, -0.08554251, -0.093893752, -0.10170748, -0.10894403, -0.1155684, -0.12155045, -0.12686516, -0.13149274, -0.13541876, -0.13863416, -0.1411353, -0.14292389, -0.14400686, -0.14439626, -0.14410905, -0.14316686, -0.1415957, -0.13942569, -0.13669069, -0.1334279, -0.12967752, -0.12548227, -0.12088699, -0.11593818, -0.11068356, -0.10517159, -0.099451049, -0.093570567, -0.087578202, -0.081521022, -0.075444716, -0.069393216, -0.063408356, -0.057529559, -0.051793558, -0.046234148, -0.040881982, -0.035764398, -0.030905288, -0.026325013, -0.022040342, -0.018064449], [0.064817553, 0.072567801, 0.080292992, 0.087918235, 0.095367076, 0.10256232, 0.10942687, 0.1158846, 0.12186124, 0.12728523, 0.13208858, 0.13620771, 0.13958427, 0.14216587, 0.14390678, 0.14476863, 0.1447209, 0.14374148, 0.14181704, 0.13894336, 0.13512554, 0.13037812, 0.1247251, 0.11819984, 0.11084487, 0.10271159, 0.093859853, 0.084357497, 0.074279719, 0.063708406, 0.052731374, 0.041441525, 0.029935953, 0.018314987, 0.0066811877, -0.0048616765, -0.016209689, -0.027259848, -0.037911124, -0.048065512, -0.05762905, -0.066512804, -0.0746338, -0.081915903, -0.088290621, -0.09369783, -0.098086416, -0.10141482, -0.10365146, -0.10477512, -0.10477512, -0.10365146, -0.10141482, -0.098086416, -0.09369783, -0.088290621, -0.081915903, -0.0746338, -0.066512804, -0.05762905, -0.048065512, -0.037911124, -0.027259848, -0.016209689, -0.0048616765, 0.0066811877, 0.018314987, 0.029935953, 0.041441525, 0.052731374, 0.063708406, 0.074279719, 0.084357497, 0.093859853, 0.10271159, 0.11084487, 0.11819984, 0.1247251, 0.13037812, 0.13512554, 0.13894336, 0.14181704, 0.14374148, 0.1447209, 0.14476863, 0.14390678, 0.14216587, 0.13958427, 0.13620771, 0.13208858, 0.12728523, 0.12186124, 0.1158846, 0.10942687, 0.10256232, 0.095367076, 0.087918235, 0.080292992, 0.072567801, 0.064817553], [0.14985551, 0.15512305, 0.15931467, 0.16236806, 0.16423291, 0.16487165, 0.16426009, 0.1623879, 0.1592589, 0.15489114, 0.14931693, 0.14258255, 0.13474785, 0.1258857, 0.11608124, 0.10543095, 0.094041635, 0.082029213, 0.069517411, 0.056636348, 0.043521028, 0.030309756, 0.017142511, 0.0041592774, -0.0085016282, -0.020705223, -0.032321494, -0.043226982, -0.053306291, -0.062453515, -0.070573544, -0.077583253, -0.083412547, -0.088005244, -0.091319802, -0.093329861, -0.094024602, -0.093408915, -0.091503383, -0.08834406, -0.08398207, -0.078483012, -0.071926192, -0.064403681, -0.056019215, -0.046886954, -0.037130106, -0.026879442, -0.016271713, -0.005448, 0.005448, 0.016271713, 0.026879442, 0.037130106, 0.046886954, 0.056019215, 0.064403681, 0.071926192, 0.078483012, 0.08398207, 0.08834406, 0.091503383, 0.093408915, 0.094024602, 0.093329861, 0.091319802, 0.088005244, 0.083412547, 0.077583253, 0.070573544, 0.062453515, 0.053306291, 0.043226982, 0.032321494, 0.020705223, 0.0085016282, -0.0041592774, -0.017142511, -0.030309756, -0.043521028, -0.056636348, -0.069517411, -0.082029213, -0.094041635, -0.10543095, -0.11608124, -0.1258857, -0.13474785, -0.14258255, -0.14931693, -0.15489114, -0.1592589, -0.1623879, -0.16426009, -0.16487165, -0.16423291, -0.16236806, -0.15931467, -0.15512305, -0.14985551]], [0.999943140, 0.997571533, 0.959465463, 0.721862496]), # noqa: E501\n}\n\n\nclass TestDPSS(object):\n\n def test_basic(self):\n # Test against hardcoded data\n for k, v in dpss_data.items():\n win, ratios = windows.dpss(*k, return_ratios=True)\n assert_allclose(win, v[0], atol=1e-7, err_msg=k)\n assert_allclose(ratios, v[1], rtol=1e-5, atol=1e-7, err_msg=k)\n\n def test_unity(self):\n # Test unity value handling (gh-2221)\n for M in range(1, 21):\n # corrected w/approximation (default)\n win = windows.dpss(M, M / 2.1)\n expected = M % 2 # one for odd, none for even\n assert_equal(np.isclose(win, 1.).sum(), expected,\n err_msg='%s' % (win,))\n # corrected w/subsample delay (slower)\n win_sub = windows.dpss(M, M / 2.1, norm='subsample')\n if M > 2:\n # @M=2 the subsample doesn't do anything\n assert_equal(np.isclose(win_sub, 1.).sum(), expected,\n err_msg='%s' % (win_sub,))\n assert_allclose(win, win_sub, rtol=0.03) # within 3%\n # not the same, l2-norm\n win_2 = windows.dpss(M, M / 2.1, norm=2)\n expected = 1 if M == 1 else 0\n assert_equal(np.isclose(win_2, 1.).sum(), expected,\n err_msg='%s' % (win_2,))\n\n def test_extremes(self):\n # Test extremes of alpha\n lam = windows.dpss(31, 6, 4, return_ratios=True)[1]\n assert_array_almost_equal(lam, 1.)\n lam = windows.dpss(31, 7, 4, return_ratios=True)[1]\n assert_array_almost_equal(lam, 1.)\n lam = windows.dpss(31, 8, 4, return_ratios=True)[1]\n assert_array_almost_equal(lam, 1.)\n\n def test_degenerate(self):\n # Test failures\n assert_raises(ValueError, windows.dpss, 4, 1.5, -1) # Bad Kmax\n assert_raises(ValueError, windows.dpss, 4, 1.5, -5)\n assert_raises(TypeError, windows.dpss, 4, 1.5, 1.1)\n assert_raises(ValueError, windows.dpss, 3, 1.5, 3) # NW must be < N/2.\n assert_raises(ValueError, windows.dpss, 3, -1, 3) # NW must be pos\n assert_raises(ValueError, windows.dpss, 3, 0, 3)\n assert_raises(ValueError, windows.dpss, -1, 1, 3) # negative M\n\n\nclass TestGetWindow(object):\n\n def test_boxcar(self):\n w = windows.get_window('boxcar', 12)\n assert_array_equal(w, np.ones_like(w))\n\n # window is a tuple of len 1\n w = windows.get_window(('boxcar',), 16)\n assert_array_equal(w, np.ones_like(w))\n\n def test_cheb_odd(self):\n with suppress_warnings() as sup:\n sup.filter(UserWarning, \"This window is not suitable\")\n w = windows.get_window(('chebwin', -40), 53, fftbins=False)\n assert_array_almost_equal(w, cheb_odd_true, decimal=4)\n\n def test_cheb_even(self):\n with suppress_warnings() as sup:\n sup.filter(UserWarning, \"This window is not suitable\")\n w = windows.get_window(('chebwin', 40), 54, fftbins=False)\n assert_array_almost_equal(w, cheb_even_true, decimal=4)\n\n def test_kaiser_float(self):\n win1 = windows.get_window(7.2, 64)\n win2 = windows.kaiser(64, 7.2, False)\n assert_allclose(win1, win2)\n\n def test_invalid_inputs(self):\n # Window is not a float, tuple, or string\n assert_raises(ValueError, windows.get_window, set('hann'), 8)\n\n # Unknown window type error\n assert_raises(ValueError, windows.get_window, 'broken', 4)\n\n def test_array_as_window(self):\n # github issue 3603\n osfactor = 128\n sig = np.arange(128)\n\n win = windows.get_window(('kaiser', 8.0), osfactor // 2)\n with assert_raises(ValueError, match='must have the same length'):\n resample(sig, len(sig) * osfactor, window=win)\n\n\ndef test_windowfunc_basics():\n for window_name, params in window_funcs:\n window = getattr(windows, window_name)\n with suppress_warnings() as sup:\n sup.filter(UserWarning, \"This window is not suitable\")\n if window_name in ('hanning',):\n sup.filter(DeprecationWarning)\n # Check symmetry for odd and even lengths\n w1 = window(8, *params, sym=True)\n w2 = window(7, *params, sym=False)\n assert_array_almost_equal(w1[:-1], w2)\n\n w1 = window(9, *params, sym=True)\n w2 = window(8, *params, sym=False)\n assert_array_almost_equal(w1[:-1], w2)\n\n # Check that functions run and output lengths are correct\n assert_equal(len(window(6, *params, sym=True)), 6)\n assert_equal(len(window(6, *params, sym=False)), 6)\n assert_equal(len(window(7, *params, sym=True)), 7)\n assert_equal(len(window(7, *params, sym=False)), 7)\n\n # Check invalid lengths\n assert_raises(ValueError, window, 5.5, *params)\n assert_raises(ValueError, window, -7, *params)\n\n # Check degenerate cases\n assert_array_equal(window(0, *params, sym=True), [])\n assert_array_equal(window(0, *params, sym=False), [])\n assert_array_equal(window(1, *params, sym=True), [1])\n assert_array_equal(window(1, *params, sym=False), [1])\n\n # Check dtype\n assert_(window(0, *params, sym=True).dtype == 'float')\n assert_(window(0, *params, sym=False).dtype == 'float')\n assert_(window(1, *params, sym=True).dtype == 'float')\n assert_(window(1, *params, sym=False).dtype == 'float')\n assert_(window(6, *params, sym=True).dtype == 'float')\n assert_(window(6, *params, sym=False).dtype == 'float')\n\n # Check normalization\n assert_array_less(window(10, *params, sym=True), 1.01)\n assert_array_less(window(10, *params, sym=False), 1.01)\n assert_array_less(window(9, *params, sym=True), 1.01)\n assert_array_less(window(9, *params, sym=False), 1.01)\n\n # Check that DFT-even spectrum is purely real for odd and even\n assert_allclose(fft(window(10, *params, sym=False)).imag,\n 0, atol=1e-14)\n assert_allclose(fft(window(11, *params, sym=False)).imag,\n 0, atol=1e-14)\n\n\ndef test_needs_params():\n for winstr in ['kaiser', 'ksr', 'gaussian', 'gauss', 'gss',\n 'general gaussian', 'general_gaussian',\n 'general gauss', 'general_gauss', 'ggs',\n 'dss', 'dpss',\n 'chebwin', 'cheb', 'exponential', 'poisson', 'tukey',\n 'tuk', 'dpss']:\n assert_raises(ValueError, get_window, winstr, 7)\n\n\ndef test_deprecation():\n if dep_hann.__doc__ is not None: # can be None with `-OO` mode\n assert_('signal.hann is deprecated' in dep_hann.__doc__)\n assert_('deprecated' not in windows.hann.__doc__)\n\n\ndef test_deprecated_pickleable():\n dep_hann2 = pickle.loads(pickle.dumps(dep_hann))\n assert_(dep_hann2 is dep_hann)\n"
] |
[
[
"scipy.signal.windows.hamming",
"numpy.testing.assert_allclose",
"numpy.ones_like",
"numpy.isclose",
"scipy.signal.windows.chebwin",
"scipy.signal.windows.general_hamming",
"scipy.signal.windows.flattop",
"numpy.testing.suppress_warnings",
"scipy.signal.windows.boxcar",
"scipy.signal.windows.kaiser",
"scipy.signal.windows.tukey",
"numpy.testing.assert_array_almost_equal",
"numpy.arange",
"scipy.signal.windows.triang",
"scipy.signal.windows.get_window",
"scipy.signal.windows.gaussian",
"scipy.signal.windows.blackman",
"numpy.array",
"numpy.testing.assert_",
"scipy.signal.windows.hann",
"scipy.signal.windows.general_cosine",
"scipy.signal.windows.bohman",
"scipy.signal.windows.bartlett",
"scipy.signal.windows.exponential",
"scipy.signal.windows.parzen",
"scipy.signal.windows.nuttall",
"scipy.signal.windows.barthann",
"scipy.signal.windows.blackmanharris",
"scipy.signal.windows.dpss"
]
] |
Liambeguin/git-pandas
|
[
"e56b817b1d66b8296d1d5e703d5db0e181d25899"
] |
[
"gitpandas/project.py"
] |
[
"\"\"\"\n.. module:: projectdirectory\n :platform: Unix, Windows\n :synopsis: A module for examining collections of git repositories as a whole\n\n.. moduleauthor:: Will McGinnis <will@pedalwrencher.com>\n\n\n\"\"\"\n\nimport math\nimport sys\nimport os\nimport numpy as np\nimport pandas as pd\nimport requests\nimport warnings\nfrom git import GitCommandError\nfrom gitpandas.repository import Repository\n\ntry:\n from joblib import delayed, Parallel\n\n _has_joblib = True\nexcept ImportError as e:\n _has_joblib = False\n\n__author__ = 'willmcginnis'\n\n\n# Functions for joblib.\ndef _branches_func(r):\n return r.branches()\n\n\ndef _revs_func(repo, branch, limit, skip, num_datapoints):\n return repo.revs(branch=branch, limit=limit, skip=skip, num_datapoints=num_datapoints)\n\n\ndef _tags_func(repo):\n return repo.tags()\n\n\nclass ProjectDirectory(object):\n \"\"\"\n An object that refers to a directory full of git repositories, for bulk analysis. It contains a collection of\n git-pandas repository objects, created by os.walk-ing a directory to file all child .git subdirectories.\n\n :param working_dir: (optional, default=None), the working directory to search for repositories in, None for cwd, or an explicit list of directories containing git repositories\n :param ignore_repos: (optional, default=None), a list of directories to ignore when searching for git repos.\n :param verbose: (default=True), if True, will print out verbose logging to terminal\n :param verbose: optional, verbosity level of output, bool\n :param tmp_dir: optional, a path to clone the repo into if necessary. Will create one if none passed.\n :param cache_backend: optional, an instantiated cache backend from gitpandas.cache\n :return:\n \"\"\"\n def __init__(self, working_dir=None, ignore_repos=None, verbose=True, tmp_dir=None, cache_backend=None):\n if working_dir is None:\n self.repo_dirs = set([x[0].split('.git')[0] for x in os.walk(os.getcwd()) if '.git' in x[0]])\n elif isinstance(working_dir, list):\n self.repo_dirs = working_dir\n else:\n self.repo_dirs = set([x[0].split('.git')[0] for x in os.walk(working_dir) if '.git' in x[0]])\n\n self.repos = [Repository(r, verbose=verbose, tmp_dir=tmp_dir, cache_backend=cache_backend) for r in self.repo_dirs]\n\n if ignore_repos is not None:\n self.repos = [x for x in self.repos if x.repo_name not in ignore_repos]\n\n def _repo_name(self):\n warnings.warn('please use repo_name() now instead of _repo_name()', DeprecationWarning)\n return self.repo_name()\n\n def repo_name(self):\n \"\"\"\n Returns a DataFrame of the repo names present in this project directory\n\n :return: DataFrame\n\n \"\"\"\n\n ds = [[x.repo_name] for x in self.repos]\n df = pd.DataFrame(ds, columns=['repository'])\n return df\n\n def is_bare(self):\n \"\"\"\n Returns a dataframe of repo names and whether or not they are bare.\n\n :return: DataFrame\n \"\"\"\n\n ds = [[x.repo_name, x.is_bare()] for x in self.repos]\n df = pd.DataFrame(ds, columns=['repository', 'is_bare'])\n return df\n\n def has_coverage(self):\n \"\"\"\n Returns a DataFrame of repo names and whether or not they have a .coverage file that can be parsed\n\n :return: DataFrame\n \"\"\"\n\n ds = [[x.repo_name, x.has_coverage()] for x in self.repos]\n df = pd.DataFrame(ds, columns=['repository', 'has_coverage'])\n return df\n\n def coverage(self):\n \"\"\"\n Will return a DataFrame with coverage information (if available) for each repo in the project).\n\n If there is a .coverage file available, this will attempt to form a DataFrame with that information in it, which\n will contain the columns:\n\n * repository\n * filename\n * lines_covered\n * total_lines\n * coverage\n\n If it can't be found or parsed, an empty DataFrame of that form will be returned.\n\n :return: DataFrame\n \"\"\"\n\n df = pd.DataFrame(columns=['filename', 'lines_covered', 'total_lines', 'coverage', 'repository'])\n\n for repo in self.repos:\n try:\n cov = repo.coverage()\n cov['repository'] = repo.repo_name\n df = df.append(cov)\n except GitCommandError:\n print('Warning! Repo: %s seems to not have coverage' % (repo, ))\n\n df.reset_index()\n\n return df\n\n def file_change_rates(self, branch='master', limit=None, coverage=False, days=None, ignore_globs=None, include_globs=None):\n \"\"\"\n This function will return a DataFrame containing some basic aggregations of the file change history data, and\n optionally test coverage data from a coverage_data.py .coverage file. The aim here is to identify files in the\n project which have abnormal edit rates, or the rate of changes without growing the files size. If a file has\n a high change rate and poor test coverage, then it is a great candidate for writing more tests.\n\n :param branch: (optional, default=master) the branch to return commits for\n :param limit: (optional, default=None) a maximum number of commits to return, None for no limit\n :param coverage: (optional, default=False) a bool for whether or not to attempt to join in coverage data.\n :param days: (optional, default=None) number of days to return if limit is None\n :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing\n :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.\n :return: DataFrame\n \"\"\"\n\n columns = ['unique_committers', 'abs_rate_of_change', 'net_rate_of_change', 'net_change', 'abs_change', 'edit_rate', 'repository']\n if coverage:\n columns += ['lines_covered', 'total_lines', 'coverage']\n df = pd.DataFrame(columns=columns)\n\n for repo in self.repos:\n try:\n fcr = repo.file_change_rates(\n branch=branch,\n limit=limit,\n coverage=coverage,\n days=days,\n ignore_globs=ignore_globs,\n include_globs=include_globs\n )\n fcr['repository'] = repo.repo_name\n df = df.append(fcr)\n except GitCommandError:\n print('Warning! Repo: %s seems to not have the branch: %s' % (repo, branch))\n\n df.reset_index()\n\n return df\n\n def hours_estimate(self, branch='master', grouping_window=0.5, single_commit_hours=0.5, limit=None, days=None, committer=True, by=None, ignore_globs=None, include_globs=None):\n \"\"\"\n inspired by: https://github.com/kimmobrunfeldt/git-hours/blob/8aaeee237cb9d9028e7a2592a25ad8468b1f45e4/index.js#L114-L143\n\n Iterates through the commit history of repo to estimate the time commitement of each author or committer over\n the course of time indicated by limit/extensions/days/etc.\n\n :param branch: the branch to return commits for\n :param limit: (optional, default=None) a maximum number of commits to return, None for no limit\n :param grouping_window: (optional, default=0.5 hours) the threhold for how close two commits need to be to consider them part of one coding session\n :param single_commit_hours: (optional, default 0.5 hours) the time range to associate with one single commit\n :param days: (optional, default=None) number of days to return, if limit is None\n :param committer: (optional, default=True) whether to use committer vs. author\n :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing\n :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.\n :return: DataFrame\n \"\"\"\n\n if limit is not None:\n limit = int(limit / len(self.repo_dirs))\n\n if committer:\n com = 'committer'\n else:\n com = 'author'\n\n df = pd.DataFrame(columns=[com, 'hours', 'repository'])\n\n for repo in self.repos:\n try:\n ch = repo.hours_estimate(\n branch,\n grouping_window=grouping_window,\n single_commit_hours=single_commit_hours,\n limit=limit,\n days=days,\n committer=committer,\n ignore_globs=ignore_globs,\n include_globs=include_globs\n )\n ch['repository'] = repo.repo_name\n df = df.append(ch)\n except GitCommandError:\n print('Warning! Repo: %s seems to not have the branch: %s' % (repo, branch))\n\n df.reset_index()\n\n if by == 'committer' or by == 'author':\n df = df.groupby(com).agg({'hours': sum})\n df = df.reset_index()\n elif by == 'repository':\n df = df.groupby('repository').agg({'hours': sum})\n df = df.reset_index()\n\n return df\n\n def commit_history(self, branch, limit=None, days=None, ignore_globs=None, include_globs=None):\n \"\"\"\n Returns a pandas DataFrame containing all of the commits for a given branch. The results from all repositories\n are appended to each other, resulting in one large data frame of size <limit>. If a limit is provided, it is\n divided by the number of repositories in the project directory to find out how many commits to pull from each\n project. Future implementations will use date ordering across all projects to get the true most recent N commits\n across the project.\n\n Included in that DataFrame will be the columns:\n\n * repository\n * date (index)\n * author\n * committer\n * message\n * lines\n * insertions\n * deletions\n * net\n\n :param branch: the branch to return commits for\n :param limit: (optional, default=None) a maximum number of commits to return, None for no limit\n :param days: (optional, default=None) number of days to return if limit is None\n :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing\n :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.\n :return: DataFrame\n \"\"\"\n\n if limit is not None:\n limit = int(limit / len(self.repo_dirs))\n\n df = pd.DataFrame(columns=['author', 'committer', 'message', 'lines', 'insertions', 'deletions', 'net'])\n\n for repo in self.repos:\n try:\n ch = repo.commit_history(branch, limit=limit, days=days, ignore_globs=ignore_globs, include_globs=include_globs)\n ch['repository'] = repo.repo_name\n df = df.append(ch)\n except GitCommandError:\n print('Warning! Repo: %s seems to not have the branch: %s' % (repo, branch))\n\n df.reset_index()\n\n return df\n\n def file_change_history(self, branch='master', limit=None, days=None, ignore_globs=None, include_globs=None):\n \"\"\"\n Returns a DataFrame of all file changes (via the commit history) for the specified branch. This is similar to\n the commit history DataFrame, but is one row per file edit rather than one row per commit (which may encapsulate\n many file changes). Included in the DataFrame will be the columns:\n\n * repository\n * date (index)\n * author\n * committer\n * message\n * filename\n * insertions\n * deletions\n\n :param branch: the branch to return commits for\n :param limit: (optional, default=None) a maximum number of commits to return, None for no limit\n :param days: (optional, default=None) number of days to return if limit is None\n :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing\n :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.\n :return: DataFrame\n \"\"\"\n\n if limit is not None:\n limit = int(limit / len(self.repo_dirs))\n\n df = pd.DataFrame(columns=['repository', 'date', 'author', 'committer', 'message', 'rev', 'filename', 'insertions', 'deletions'])\n\n for repo in self.repos:\n try:\n ch = repo.file_change_history(\n branch,\n limit=limit,\n days=days,\n ignore_globs=ignore_globs,\n include_globs=include_globs\n )\n ch['repository'] = repo.repo_name\n df = df.append(ch)\n except GitCommandError:\n print('Warning! Repo: %s seems to not have the branch: %s' % (repo, branch))\n\n df.reset_index()\n\n return df\n\n def blame(self, committer=True, by='repository', ignore_globs=None, include_globs=None):\n \"\"\"\n Returns the blame from the current HEAD of the repositories as a DataFrame. The DataFrame is grouped by committer\n name, so it will be the sum of all contributions to all repositories by each committer. As with the commit history\n method, extensions and ignore_dirs parameters can be passed to exclude certain directories, or focus on certain\n file extensions. The DataFrame will have the columns:\n\n * committer\n * loc\n\n :param committer: (optional, default=True) true if committer should be reported, false if author\n :param by: (optional, default=repository) whether to group by repository or by file\n :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing\n :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.\n :return: DataFrame\n \"\"\"\n\n df = None\n\n for repo in self.repos:\n try:\n if df is None:\n df = repo.blame(committer=committer, by=by, ignore_globs=ignore_globs, include_globs=include_globs)\n else:\n df = df.append(repo.blame(committer=committer, by=by, ignore_globs=ignore_globs, include_globs=include_globs))\n except GitCommandError as err:\n print('Warning! Repo: %s couldnt be blamed' % (repo, ))\n pass\n\n df = df.reset_index(level=1)\n df = df.reset_index(level=1)\n if committer:\n if by == 'repository':\n df = df.groupby('committer').agg({'loc': np.sum})\n elif by == 'file':\n df = df.groupby(['committer', 'file']).agg({'loc': np.sum})\n else:\n if by == 'repository':\n df = df.groupby('author').agg({'loc': np.sum})\n elif by == 'file':\n df = df.groupby(['author', 'file']).agg({'loc': np.sum})\n\n df = df.sort_values(by=['loc'], ascending=False)\n\n return df\n\n def file_detail(self, rev='HEAD', committer=True, ignore_globs=None, include_globs=None):\n \"\"\"\n Returns a table of all current files in the repos, with some high level information about each file (total LOC,\n file owner, extension, most recent edit date, etc.).\n\n :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing\n :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.\n :param committer: (optional, default=True) true if committer should be reported, false if author\n :return:\n \"\"\"\n\n df = None\n\n for repo in self.repos:\n try:\n if df is None:\n df = repo.file_detail(ignore_globs=ignore_globs, include_globs=include_globs, committer=committer, rev=rev)\n df['repository'] = repo.repo_name\n else:\n chunk = repo.file_detail(ignore_globs=ignore_globs, include_globs=include_globs, committer=committer, rev=rev)\n chunk['repository'] = repo.repo_name\n df = df.append(chunk)\n except GitCommandError:\n print('Warning! Repo: %s couldnt be inspected' % (repo, ))\n\n df = df.reset_index(level=1)\n df = df.set_index(['file', 'repository'])\n return df\n\n def branches(self):\n \"\"\"\n Returns a data frame of all branches in origin. The DataFrame will have the columns:\n\n * repository\n * local\n * branch\n\n :returns: DataFrame\n \"\"\"\n\n df = pd.DataFrame(columns=['repository', 'local', 'branch'])\n\n if _has_joblib:\n ds = Parallel(n_jobs=-1, backend='threading', verbose=0)(\n delayed(_branches_func)\n (x) for x in self.repos\n )\n for d in ds:\n df = df.append(d)\n else:\n for repo in self.repos:\n try:\n df = df.append(_branches_func(repo))\n except GitCommandError:\n print('Warning! Repo: %s couldn\\'t be inspected' % (repo, ))\n\n df.reset_index()\n\n return df\n\n def revs(self, branch='master', limit=None, skip=None, num_datapoints=None):\n \"\"\"\n Returns a dataframe of all revision tags and their timestamps for each project. It will have the columns:\n\n * date\n * repository\n * rev\n\n :param branch: (optional, default 'master') the branch to work in\n :param limit: (optional, default None), the maximum number of revisions to return, None for no limit\n :param skip: (optional, default None), the number of revisions to skip. Ex: skip=2 returns every other revision, None for no skipping.\n :param num_datapoints: (optional, default=None) if limit and skip are none, and this isn't, then num_datapoints evenly spaced revs will be used\n\n :return: DataFrame\n \"\"\"\n\n if limit is not None:\n limit = math.floor(float(limit) / len(self.repos))\n\n if num_datapoints is not None:\n num_datapoints = math.floor(float(num_datapoints) / len(self.repos))\n\n df = pd.DataFrame(columns=['repository', 'rev'])\n\n if _has_joblib:\n ds = Parallel(n_jobs=-1, backend='threading', verbose=0)(\n delayed(_revs_func)\n (x, branch, limit, skip, num_datapoints) for x in self.repos\n )\n for d in ds:\n df = df.append(d)\n else:\n for repo in self.repos:\n try:\n revs = repo.revs(branch=branch, limit=limit, skip=skip, num_datapoints=num_datapoints)\n revs['repository'] = repo.repo_name\n df = df.append(revs)\n except GitCommandError:\n print('Warning! Repo: %s couldn\\'t be inspected' % (repo, ))\n\n df.reset_index()\n\n return df\n\n def cumulative_blame(self, branch='master', by='committer', limit=None, skip=None, num_datapoints=None, committer=True, ignore_globs=None, include_globs=None):\n \"\"\"\n Returns a time series of cumulative blame for a collection of projects. The goal is to return a dataframe for a\n collection of projects with the LOC attached to an entity at each point in time. The returned dataframe can be\n returned in 3 forms (switched with the by parameter, default 'committer'):\n\n * committer: one column per committer\n * project: one column per project\n * raw: one column per committed per project\n\n :param branch: (optional, default 'master') the branch to work in\n :param limit: (optional, default None), the maximum number of revisions to return, None for no limit\n :param skip: (optional, default None), the number of revisions to skip. Ex: skip=2 returns every other revision, None for no skipping.\n :param num_datapoints: (optional, default=None) if limit and skip are none, and this isn't, then num_datapoints evenly spaced revs will be used\n :param committer: (optional, default=True) true if committer should be reported, false if author\n :param by: (optional, default='committer') whether to arrange the output by committer or project\n :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing\n :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.\n :return: DataFrame\n\n \"\"\"\n\n blames = []\n for repo in self.repos:\n try:\n blame = repo.cumulative_blame(\n branch=branch,\n limit=limit,\n skip=skip,\n num_datapoints=num_datapoints,\n committer=committer,\n ignore_globs=ignore_globs,\n include_globs=include_globs\n )\n blames.append((repo.repo_name, blame))\n except GitCommandError:\n print('Warning! Repo: %s couldn\\'t be inspected' % (repo, ))\n pass\n\n global_blame = blames[0][1]\n global_blame.columns = [x + '__' + str(blames[0][0]) for x in global_blame.columns.values]\n blames = blames[1:]\n for reponame, blame in blames:\n blame.columns = [x + '__' + reponame for x in blame.columns.values]\n global_blame = pd.merge(global_blame, blame, left_index=True, right_index=True, how='outer')\n\n global_blame.fillna(method='pad', inplace=True)\n global_blame.fillna(0.0, inplace=True)\n\n if by == 'committer':\n committers = [(str(x).split('__')[0].lower().strip(), x) for x in global_blame.columns.values]\n\n if sys.version_info.major == 2:\n committer_mapping = dict([(c, [x[1] for x in committers if x[0] == c]) for c in set([x[0] for x in committers])])\n else:\n committer_mapping = {c: [x[1] for x in committers if x[0] == c] for c in {x[0] for x in committers}}\n\n for committer in committer_mapping.keys():\n global_blame[committer] = 0\n for col in committer_mapping.get(committer, []):\n global_blame[committer] += global_blame[col]\n\n global_blame = global_blame.reindex(columns=list(committer_mapping.keys()))\n elif by == 'project':\n projects = [(str(x).split('__')[1].lower().strip(), x) for x in global_blame.columns.values]\n\n if sys.version_info.major == 2:\n project_mapping = dict([(c, [x[1] for x in projects if x[0] == c]) for c in set([x[0] for x in projects])])\n else:\n project_mapping = {c: [x[1] for x in projects if x[0] == c] for c in {x[0] for x in projects}}\n\n for project in project_mapping.keys():\n global_blame[project] = 0\n for col in project_mapping.get(project, []):\n global_blame[project] += global_blame[col]\n\n global_blame = global_blame.reindex(columns=list(project_mapping.keys()))\n\n global_blame = global_blame[~global_blame.index.duplicated()]\n\n return global_blame\n\n def tags(self):\n \"\"\"\n Returns a data frame of all tags in origin. The DataFrame will have the columns:\n\n * repository\n * tag\n\n :returns: DataFrame\n \"\"\"\n\n df = pd.DataFrame(columns=['repository', 'tag'])\n\n if _has_joblib:\n ds = Parallel(n_jobs=-1, backend='threading', verbose=0)(\n delayed(_tags_func)\n (x) for x in self.repos\n )\n for d in ds:\n df = df.append(d)\n else:\n for repo in self.repos:\n try:\n df = df.append(repo.tags())\n except GitCommandError:\n print('Warning! Repo: %s couldn\\'t be inspected' % (repo, ))\n\n df.reset_index()\n\n return df\n\n def repo_information(self):\n \"\"\"\n Returns a DataFrame with the properties of all repositories in the project directory. The returned DataFrame\n will have the columns:\n\n * local_directory\n * branches\n * bare\n * remotes\n * description\n * references\n * heads\n * submodules\n * tags\n * active_branch\n\n :return: DataFrame\n \"\"\"\n\n data = [[repo.git_dir,\n repo.repo.branches,\n repo.repo.bare,\n repo.repo.remotes,\n repo.repo.description,\n repo.repo.references,\n repo.repo.heads,\n repo.repo.submodules,\n repo.repo.tags,\n repo.repo.active_branch] for repo in self.repos]\n\n df = pd.DataFrame(data, columns=[\n 'local_directory',\n 'branches',\n 'bare',\n 'remotes',\n 'description',\n 'references',\n 'heads',\n 'submodules',\n 'tags',\n 'active_branch'\n ])\n\n return df\n\n def bus_factor(self, ignore_globs=None, include_globs=None, by='projectd'):\n \"\"\"\n An experimental heuristic for truck factor of a repository calculated by the current distribution of blame in\n the repository's primary branch. The factor is the fewest number of contributors whose contributions make up at\n least 50% of the codebase's LOC\n\n :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing\n :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.\n\n :return:\n \"\"\"\n\n if by == 'file':\n raise NotImplementedError('File-wise bus factor')\n elif by == 'projectd':\n blame = self.blame(ignore_globs=ignore_globs, include_globs=include_globs, by='repository')\n blame = blame.sort_values(by=['loc'], ascending=False)\n\n total = blame['loc'].sum()\n cumulative = 0\n tc = 0\n for idx in range(blame.shape[0]):\n cumulative += blame.ix[idx, 'loc']\n tc += 1\n if cumulative >= total / 2:\n break\n\n return pd.DataFrame([['projectd', tc]], columns=['projectd', 'bus factor'])\n elif by == 'repository':\n df = pd.DataFrame(columns=['repository', 'bus factor'])\n for repo in self.repos:\n try:\n df = df.append(repo.bus_factor(ignore_globs=include_globs, include_globs=include_globs, by=by))\n except GitCommandError:\n print('Warning! Repo: %s couldn\\'t be inspected' % (repo, ))\n\n df.reset_index()\n return df\n\n def punchcard(self, branch='master', limit=None, days=None, by=None, normalize=None, ignore_globs=None, include_globs=None):\n \"\"\"\n Returns a pandas DataFrame containing all of the data for a punchcard.\n\n * day_of_week\n * hour_of_day\n * author / committer\n * lines\n * insertions\n * deletions\n * net\n\n :param branch: the branch to return commits for\n :param limit: (optional, default=None) a maximum number of commits to return, None for no limit\n :param days: (optional, default=None) number of days to return, if limit is None\n :param by: (optional, default=None) agg by options, None for no aggregation (just a high level punchcard), or 'committer', 'author', 'repository'\n :param normalize: (optional, default=None) if an integer, returns the data normalized to max value of that (for plotting)\n :param ignore_globs: (optional, default=None) a list of globs to ignore, default none excludes nothing\n :param include_globs: (optinal, default=None) a list of globs to include, default of None includes everything.\n :return: DataFrame\n \"\"\"\n\n df = pd.DataFrame()\n\n if by == 'repository':\n repo_by = None\n else:\n repo_by = by\n\n for repo in self.repos:\n try:\n chunk = repo.punchcard(\n branch=branch,\n limit=limit,\n days=days,\n by=repo_by,\n normalize=None,\n ignore_globs=ignore_globs,\n include_globs=include_globs\n )\n chunk['repository'] = repo.repo_name\n df = df.append(chunk)\n except GitCommandError:\n print('Warning! Repo: %s couldn\\'t be inspected' % (repo, ))\n\n df.reset_index()\n\n aggs = ['hour_of_day', 'day_of_week']\n if by is not None:\n aggs.append(by)\n\n punch_card = df.groupby(aggs).agg({\n 'lines': np.sum,\n 'insertions': np.sum,\n 'deletions': np.sum,\n 'net': np.sum\n })\n punch_card.reset_index(inplace=True)\n\n # normalize all cols\n if normalize is not None:\n for col in ['lines', 'insertions', 'deletions', 'net']:\n punch_card[col] = (punch_card[col] / punch_card[col].sum()) * normalize\n\n return punch_card\n\n def __del__(self):\n \"\"\"\n\n :return:\n \"\"\"\n\n for repo in self.repos:\n repo.__del__()\n\n\nclass GitHubProfile(ProjectDirectory):\n \"\"\"\n An extension of the ProjectDirectory object that is based off of a single github.com user's public profile.\n \"\"\"\n def __init__(self, username, ignore_forks=False, ignore_repos=None, verbose=False):\n \"\"\"\n\n :param username:\n :return:\n \"\"\"\n\n # pull the git urls from github's api\n uri = 'https://api.github.com/users/%s/repos' % username\n data = requests.get(uri)\n repos = []\n for chunk in data.json():\n # if we are skipping forks\n if ignore_forks:\n if not chunk['fork']:\n repos.append(chunk['git_url'])\n else:\n repos.append(chunk['git_url'])\n\n ProjectDirectory.__init__(self, working_dir=repos, ignore_repos=ignore_repos, verbose=verbose)\n"
] |
[
[
"pandas.DataFrame",
"pandas.merge"
]
] |
Guillemdb/fragile
|
[
"ea8203508752e76b80495cfe057985268564bf4a"
] |
[
"fragile/optimize/env.py"
] |
[
"from typing import Callable, Dict, Tuple, Union\n\nimport judo\nfrom judo import Backend, Bounds, tensor, typing\nimport numpy\nfrom scipy.optimize import Bounds as ScipyBounds\nfrom scipy.optimize import minimize\n\nfrom fragile.core.env import Environment\nfrom fragile.core.states import StatesEnv, StatesModel\n\n\nclass Function(Environment):\n \"\"\"\n Environment that represents an arbitrary mathematical function bounded in a \\\n given interval.\n \"\"\"\n\n def __init__(\n self,\n function: Callable[[typing.Tensor], typing.Tensor],\n bounds: Bounds,\n custom_domain_check: Callable[[typing.Tensor, typing.Tensor, int], typing.Tensor] = None,\n actions_as_perturbations: bool = True,\n ):\n \"\"\"\n Initialize a :class:`Function`.\n\n Args:\n function: Callable that takes a batch of vectors (batched across \\\n the first dimension of the array) and returns a vector of \\\n typing.Scalar. This function is applied to a batch of walker \\\n observations.\n bounds: :class:`Bounds` that defines the domain of the function.\n custom_domain_check: Callable that checks points inside the bounds \\\n to know if they are in a custom domain when it is not just \\\n a set of rectangular bounds. It takes a batch of points as \\\n input and returns an array of booleans. Each ``True`` value \\\n indicates that the corresponding point is **outside** the \\\n ``custom_domain_check``.\n actions_as_perturbations: If ``True`` the actions are interpreted as \\\n perturbations that will be applied to the past states. \\\n If ``False`` the actions are interpreted as the new states to \\\n be evaluated.\n\n \"\"\"\n if not isinstance(bounds, Bounds):\n raise TypeError(\"Bounds needs to be an instance of Bounds, found {}\".format(bounds))\n self.function = function\n self.bounds = bounds\n self.custom_domain_check = custom_domain_check\n self._actions_as_perturbations = actions_as_perturbations\n super(Function, self).__init__(observs_shape=self.shape, states_shape=self.shape)\n\n @property\n def n_dims(self) -> int:\n \"\"\"Return the number of dimensions of the function to be optimized.\"\"\"\n return len(self.bounds)\n\n @property\n def shape(self) -> Tuple[int, ...]:\n \"\"\"Return the shape of the environment.\"\"\"\n return self.bounds.shape\n\n @classmethod\n def from_bounds_params(\n cls,\n function: Callable,\n shape: tuple = None,\n high: Union[int, float, typing.Tensor] = numpy.inf,\n low: Union[int, float, typing.Tensor] = numpy.NINF,\n custom_domain_check: Callable[[typing.Tensor], typing.Tensor] = None,\n ) -> \"Function\":\n \"\"\"\n Initialize a function defining its shape and bounds without using a :class:`Bounds`.\n\n Args:\n function: Callable that takes a batch of vectors (batched across \\\n the first dimension of the array) and returns a vector of \\\n typing.Scalar. This function is applied to a batch of walker \\\n observations.\n shape: Input shape of the solution vector without taking into account \\\n the batch dimension. For example, a two dimensional function \\\n applied to a batch of 5 walkers will have shape=(2,), even though\n the observations will have shape (5, 2)\n high: Upper bound of the function domain. If it's an typing.Scalar it will \\\n be the same for all dimensions. If its a numpy array it will \\\n be the upper bound for each dimension.\n low: Lower bound of the function domain. If it's an typing.Scalar it will \\\n be the same for all dimensions. If its a numpy array it will \\\n be the lower bound for each dimension.\n custom_domain_check: Callable that checks points inside the bounds \\\n to know if they are in a custom domain when it is not just \\\n a set of rectangular bounds.\n\n Returns:\n :class:`Function` with its :class:`Bounds` created from the provided arguments.\n\n \"\"\"\n if (\n not (judo.is_tensor(high) or isinstance(high, (list, tuple)))\n and not (judo.is_tensor(low) or isinstance(low, (list, tuple)))\n and shape is None\n ):\n raise TypeError(\"Need to specify shape or high or low must be a numpy array.\")\n bounds = Bounds(high=high, low=low, shape=shape)\n return Function(function=function, bounds=bounds, custom_domain_check=custom_domain_check)\n\n def __repr__(self):\n text = \"{} with function {}, obs shape {},\".format(\n self.__class__.__name__, self.function.__name__, self.shape,\n )\n return text\n\n def states_to_data(\n self, model_states: StatesModel, env_states: StatesEnv\n ) -> Dict[str, typing.Tensor]:\n \"\"\"\n Extract the data that will be used to make the state transitions.\n\n Args:\n model_states: :class:`StatesModel` representing the data to be used \\\n to act on the environment.\n env_states: :class:`StatesEnv` representing the data to be set in \\\n the environment.\n\n Returns:\n Dictionary containing:\n\n ``{\"observs\": np.array, \"actions\": np.array}``\n\n \"\"\"\n data = {\"observs\": env_states.states, \"actions\": model_states.actions}\n return data\n\n def make_transitions(\n self, observs: typing.Tensor, actions: typing.Tensor\n ) -> Dict[str, typing.Tensor]:\n \"\"\"\n\n Sum the target action to the observations to obtain the new points, and \\\n evaluate the reward and boundary conditions.\n\n Args:\n observs: Batch of points returned in the last step.\n actions: Perturbation that will be applied to ``observs``.\n\n Returns:\n Dictionary containing the information of the new points evaluated.\n\n ``{\"states\": new_points, \"observs\": new_points, \"rewards\": typing.Scalar array, \\\n \"oobs\": boolean array}``\n\n \"\"\"\n new_points = actions + observs if self._actions_as_perturbations else actions\n rewards = self.function(new_points).flatten()\n oobs = self.calculate_oobs(points=new_points, rewards=rewards)\n data = {\"states\": new_points, \"observs\": new_points, \"rewards\": rewards, \"oobs\": oobs}\n return data\n\n def reset(self, batch_size: int = 1, **kwargs) -> StatesEnv:\n \"\"\"\n Reset the :class:`Function` to the start of a new episode and returns \\\n an :class:`StatesEnv` instance describing its internal state.\n\n Args:\n batch_size: Number of walkers that the returned state will have.\n **kwargs: Ignored. This environment resets without using any external data.\n\n Returns:\n :class:`EnvStates` instance describing the state of the :class:`Function`. \\\n The first dimension of the data tensors (number of walkers) will be \\\n equal to batch_size.\n\n \"\"\"\n oobs = judo.zeros(batch_size, dtype=judo.bool)\n new_points = self.sample_bounds(batch_size=batch_size)\n rewards = self.function(new_points).flatten()\n new_states = self.states_from_data(\n states=new_points,\n observs=new_points,\n rewards=rewards,\n oobs=oobs,\n batch_size=batch_size,\n )\n return new_states\n\n def calculate_oobs(self, points: typing.Tensor, rewards: typing.Tensor) -> typing.Tensor:\n \"\"\"\n Determine if a given batch of vectors lie inside the function domain.\n\n Args:\n points: Array of batched vectors that will be checked to lie inside \\\n the :class:`Function` bounds.\n rewards: Array containing the rewards of the current walkers.\n\n Returns:\n Array of booleans of length batch_size (points.shape[0]) that will \\\n be ``True`` if a given point of the batch lies outside the bounds, \\\n and ``False`` otherwise.\n\n \"\"\"\n oobs = judo.logical_not(self.bounds.points_in_bounds(points)).flatten()\n if self.custom_domain_check is not None:\n points_in_bounds = judo.logical_not(oobs)\n oobs[points_in_bounds] = self.custom_domain_check(\n points[points_in_bounds], rewards[points_in_bounds], len(rewards)\n )\n return oobs\n\n def sample_bounds(self, batch_size: int) -> typing.Tensor:\n \"\"\"\n Return a matrix of points sampled uniformly from the :class:`Function` \\\n domain.\n\n Args:\n batch_size: Number of points that will be sampled.\n\n Returns:\n Array containing ``batch_size`` points that lie inside the \\\n :class:`Function` domain, stacked across the first dimension.\n\n \"\"\"\n new_points = judo.zeros(tuple([batch_size]) + self.shape, dtype=judo.float32)\n for i in range(batch_size):\n values = self.random_state.uniform(\n low=judo.astype(self.bounds.low, judo.float),\n high=judo.astype(self.bounds.high, judo.float32),\n )\n values = judo.astype(values, self.bounds.low.dtype)\n new_points[i, :] = values\n\n return new_points\n\n\nclass Minimizer:\n \"\"\"Apply ``scipy.optimize.minimize`` to a :class:`Function`.\"\"\"\n\n def __init__(self, function: Function, bounds=None, *args, **kwargs):\n \"\"\"\n Initialize a :class:`Minimizer`.\n\n Args:\n function: :class:`Function` that will be minimized.\n bounds: :class:`Bounds` defining the domain of the minimization \\\n process. If it is ``None`` the :class:`Function` :class:`Bounds` \\\n will be used.\n *args: Passed to ``scipy.optimize.minimize``.\n **kwargs: Passed to ``scipy.optimize.minimize``.\n\n \"\"\"\n self.env = function\n self.function = function.function\n self.bounds = self.env.bounds if bounds is None else bounds\n self.args = args\n self.kwargs = kwargs\n\n def minimize(self, x: typing.Tensor):\n \"\"\"\n Apply ``scipy.optimize.minimize`` to a single point.\n\n Args:\n x: Array representing a single point of the function to be minimized.\n\n Returns:\n Optimization result object returned by ``scipy.optimize.minimize``.\n\n \"\"\"\n\n def _optimize(_x):\n try:\n _x = _x.reshape((1,) + _x.shape)\n y = self.function(_x)\n except (ZeroDivisionError, RuntimeError):\n y = numpy.inf\n return y\n\n bounds = ScipyBounds(\n ub=judo.to_numpy(self.bounds.high) if self.bounds is not None else None,\n lb=judo.to_numpy(self.bounds.low) if self.bounds is not None else None,\n )\n return minimize(_optimize, x, bounds=bounds, *self.args, **self.kwargs)\n\n def minimize_point(self, x: typing.Tensor) -> Tuple[typing.Tensor, typing.Scalar]:\n \"\"\"\n Minimize the target function passing one starting point.\n\n Args:\n x: Array representing a single point of the function to be minimized.\n\n Returns:\n Tuple containing a numpy array representing the best solution found, \\\n and the numerical value of the function at that point.\n\n \"\"\"\n optim_result = self.minimize(x)\n point = tensor(optim_result[\"x\"])\n reward = tensor(float(optim_result[\"fun\"]))\n return point, reward\n\n def minimize_batch(self, x: typing.Tensor) -> Tuple[typing.Tensor, typing.Tensor]:\n \"\"\"\n Minimize a batch of points.\n\n Args:\n x: Array representing a batch of points to be optimized, stacked \\\n across the first dimension.\n\n Returns:\n Tuple of arrays containing the local optimum found for each point, \\\n and an array with the values assigned to each of the points found.\n\n \"\"\"\n x = judo.to_numpy(judo.copy(x))\n with Backend.use_backend(\"numpy\"):\n result = judo.zeros_like(x)\n rewards = judo.zeros((x.shape[0], 1))\n for i in range(x.shape[0]):\n new_x, reward = self.minimize_point(x[i, :])\n result[i, :] = new_x\n rewards[i, :] = float(reward)\n self.bounds.high = tensor(self.bounds.high)\n self.bounds.low = tensor(self.bounds.low)\n result, rewards = tensor(result), tensor(rewards)\n return result, rewards\n\n\nclass MinimizerWrapper(Function):\n \"\"\"\n Wrapper that applies a local minimization process to the observations \\\n returned by a :class:`Function`.\n \"\"\"\n\n def __init__(self, function: Function, *args, **kwargs):\n \"\"\"\n Initialize a :class:`MinimizerWrapper`.\n\n Args:\n function: :class:`Function` to be minimized after each step.\n *args: Passed to the internal :class:`Optimizer`.\n **kwargs: Passed to the internal :class:`Optimizer`.\n\n \"\"\"\n self.env = function\n self.minimizer = Minimizer(function=self.env, *args, **kwargs)\n\n @property\n def shape(self) -> Tuple[int, ...]:\n \"\"\"Return the shape of the wrapped environment.\"\"\"\n return self.env.shape\n\n @property\n def function(self) -> Callable:\n \"\"\"Return the function of the wrapped environment.\"\"\"\n return self.env.function\n\n @property\n def bounds(self) -> Bounds:\n \"\"\"Return the bounds of the wrapped environment.\"\"\"\n return self.env.bounds\n\n @property\n def custom_domain_check(self) -> Callable:\n \"\"\"Return the custom_domain_check of the wrapped environment.\"\"\"\n return self.env.custom_domain_check\n\n def __getattr__(self, item):\n return self.env.__getattribute__(item)\n\n def __repr__(self):\n return self.env.__repr__()\n\n def step(self, model_states: StatesModel, env_states: StatesEnv) -> StatesEnv:\n \"\"\"\n Perform a local optimization process to the observations returned after \\\n calling ``step`` on the wrapped :class:`Function`.\n\n Args:\n model_states: :class:`StatesModel` corresponding to the :class:`Model` data.\n env_states: :class:`StatesEnv` containing the data where the function \\\n will be evaluated.\n\n Returns:\n States containing the information that describes the new state of \\\n the :class:`Function`.\n\n \"\"\"\n env_states = super(MinimizerWrapper, self).step(\n model_states=model_states, env_states=env_states\n )\n new_points, rewards = self.minimizer.minimize_batch(env_states.observs)\n # new_points, rewards = tensor(new_points), tensor(rewards)\n oobs = self.calculate_oobs(new_points, rewards)\n updated_states = self.states_from_data(\n states=new_points,\n observs=new_points,\n rewards=rewards.flatten(),\n oobs=oobs,\n batch_size=model_states.n,\n )\n return updated_states\n"
] |
[
[
"scipy.optimize.minimize"
]
] |
avivt/pytorch-a2c-ppo-acktr-gail
|
[
"ea18861b7d09bfb7c9ca2fda37ef08204969036c"
] |
[
"grad_tools/mediangrad.py"
] |
[
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nimport pdb\nimport numpy as np\nimport copy\nimport random\n\n\nclass MedianGrad():\n def __init__(self, optimizer, noise_ratio=1.0):\n self._optim = optimizer\n self._noise_ratio = noise_ratio\n return\n\n @property\n def optimizer(self):\n return self._optim\n\n def zero_grad(self):\n '''\n clear the gradient of the parameters\n '''\n\n return self._optim.zero_grad(set_to_none=True)\n\n def step(self):\n '''\n update the parameters with the gradient\n '''\n\n return self._optim.step()\n\n def median_backward(self, objectives):\n '''\n calculate the gradient of the parameters\n\n input:\n - objectives: a list of objectives\n '''\n\n grads, shapes, has_grads = self._pack_grad(objectives)\n noisy_grad = self._clip_and_add_noise(grads, has_grads)\n noisy_grad = self._unflatten_grad(noisy_grad, shapes[0])\n self._set_grad(noisy_grad)\n return\n\n def _clip_and_add_noise(self, grads, has_grads, shapes=None):\n shared = torch.stack(has_grads).prod(0).bool()\n pc_grad, num_task = copy.deepcopy(grads), len(grads)\n\n merged_grad = torch.zeros_like(grads[0]).to(grads[0].device)\n stacked_grads = torch.stack([g[shared] for g in grads])\n merged_grad[shared] = torch.median(stacked_grads, dim=0)[0]\n\n u = torch.rand(merged_grad.shape)\n top_quantile = np.minimum((num_task + 1) / (2 * num_task), 1.0)\n bottom_quantile = np.maximum((num_task - 1) / (2 * num_task), 0.0)\n noise_max = torch.quantile(stacked_grads.abs(), top_quantile, dim=0) - merged_grad\n noise_min = merged_grad - torch.quantile(stacked_grads.abs(), bottom_quantile, dim=0)\n noise = (u * (noise_max - noise_min) + noise_min) * self._noise_ratio\n merged_grad += noise\n\n merged_grad[~shared] = torch.stack([g[~shared]\n for g in pc_grad]).sum(dim=0)\n return merged_grad\n\n def _set_grad(self, grads):\n '''\n set the modified gradients to the network\n '''\n\n idx = 0\n for group in self._optim.param_groups:\n for p in group['params']:\n # if p.grad is None: continue\n p.grad = grads[idx]\n idx += 1\n return\n\n def _pack_grad(self, objectives):\n '''\n pack the gradient of the parameters of the network for each objective\n \n output:\n - grad: a list of the gradient of the parameters\n - shape: a list of the shape of the parameters\n - has_grad: a list of mask represent whether the parameter has gradient\n '''\n\n grads, shapes, has_grads = [], [], []\n for obj in objectives:\n self._optim.zero_grad(set_to_none=True)\n obj.backward(retain_graph=True)\n grad, shape, has_grad = self._retrieve_grad()\n grads.append(self._flatten_grad(grad, shape))\n has_grads.append(self._flatten_grad(has_grad, shape))\n shapes.append(shape)\n return grads, shapes, has_grads\n\n def _unflatten_grad(self, grads, shapes):\n unflatten_grad, idx = [], 0\n for shape in shapes:\n length = np.prod(shape)\n unflatten_grad.append(grads[idx:idx + length].view(shape).clone())\n idx += length\n return unflatten_grad\n\n def _flatten_grad(self, grads, shapes):\n flatten_grad = torch.cat([g.flatten() for g in grads])\n return flatten_grad\n\n def _retrieve_grad(self):\n '''\n get the gradient of the parameters of the network with specific \n objective\n \n output:\n - grad: a list of the gradient of the parameters\n - shape: a list of the shape of the parameters\n - has_grad: a list of mask represent whether the parameter has gradient\n '''\n\n grad, shape, has_grad = [], [], []\n for group in self._optim.param_groups:\n for p in group['params']:\n # if p.grad is None: continue\n # tackle the multi-head scenario\n if p.grad is None:\n shape.append(p.shape)\n grad.append(torch.zeros_like(p).to(p.device))\n has_grad.append(torch.zeros_like(p).to(p.device))\n continue\n shape.append(p.grad.shape)\n grad.append(p.grad.clone())\n has_grad.append(torch.ones_like(p).to(p.device))\n return grad, shape, has_grad\n\n\nclass TestNet(nn.Module):\n def __init__(self):\n super().__init__()\n self._linear = nn.Linear(3, 4)\n\n def forward(self, x):\n return self._linear(x)\n\n\nclass MultiHeadTestNet(nn.Module):\n def __init__(self):\n super().__init__()\n self._linear = nn.Linear(3, 2)\n self._head1 = nn.Linear(2, 4)\n self._head2 = nn.Linear(2, 4)\n\n def forward(self, x):\n feat = self._linear(x)\n return self._head1(feat), self._head2(feat)\n\n\nif __name__ == '__main__':\n\n # fully shared network test\n torch.manual_seed(4)\n x, y = torch.randn(2, 3), torch.randn(2, 4)\n net = TestNet()\n y_pred = net(x)\n noisy_adam = NoisyGrad(optim.Adam(net.parameters()))\n noisy_adam.zero_grad()\n loss1_fn, loss2_fn = nn.L1Loss(), nn.MSELoss()\n loss1, loss2 = loss1_fn(y_pred, y), loss2_fn(y_pred, y)\n\n noisy_adam.noisy_backward([loss1, loss2])\n for p in net.parameters():\n print(p.grad)\n\n print('-' * 80)\n # seperated shared network test\n\n torch.manual_seed(4)\n x, y = torch.randn(2, 3), torch.randn(2, 4)\n net = MultiHeadTestNet()\n y_pred_1, y_pred_2 = net(x)\n noisy_adam = NoisyGrad(optim.Adam(net.parameters()))\n noisy_adam.zero_grad()\n loss1_fn, loss2_fn = nn.MSELoss(), nn.MSELoss()\n loss1, loss2 = loss1_fn(y_pred_1, y), loss2_fn(y_pred_2, y)\n\n noisy_adam.noisy_backward([loss1, loss2])\n for p in net.parameters():\n print(p.grad)\n"
] |
[
[
"torch.nn.Linear",
"torch.rand",
"torch.stack",
"torch.nn.MSELoss",
"numpy.minimum",
"torch.nn.L1Loss",
"torch.manual_seed",
"numpy.prod",
"torch.ones_like",
"torch.median",
"torch.zeros_like",
"torch.randn",
"numpy.maximum"
]
] |
I-Doctor/fix_train
|
[
"3ddd812cd9d6c3dd14ffa059841078f033c48856"
] |
[
"code/model/module/test_qq.py"
] |
[
"import torch\nimport numpy as np\nimport h5py\nimport matplotlib.ticker as ticker\nimport matplotlib.pyplot as plt\nfrom quantize_functions import Quantize_A\n\nprefix = '../../../checkpoint/fix_experiment/imgnet/log_quantize_20200926_12-32-39/checkpoint_'\nepochnum = '28'\nmannum = 4\n\ndef plotexp(data, epoch, man):\n f = h5py.File(prefix+data+'_'+epoch+'.h5','r')\n keys = f.keys()\n fresults = np.array([])\n nresults = np.array([])\n cresults = np.array([])\n ncresults = np.array([])\n count = 0\n for layer_name in keys:\n layer_data = f[layer_name][:]\n layer_name = layer_name[0:-8] if layer_name[-1]=='b' else layer_name[0:-6]\n if layer_name[0:-1].endswith('conv'):\n if count % 8 == 0:\n print(' ',layer_name)\n shape = layer_data.shape\n print(' shape',shape)\n print(' range',layer_data.min(), layer_data.max())\n x_in = torch.Tensor(layer_data)\n\n q_xf = Quantize_A.apply(x_in, \n man, \n 0, \n False, \n False, \n False, \n 'complex', \n 'progress')\n q_xn = Quantize_A.apply(x_in, \n man, \n 1, \n False, \n False, \n False, \n 'complex', \n 'progress')\n q_xc = Quantize_A.apply(x_in, \n man, \n 2, \n False, \n False, \n False, \n 'complex', \n 'progress')\n q_xnc = Quantize_A.apply(x_in, \n man, \n 3, \n False, \n False, \n False, \n 'complex', \n 'progress')\n ef = np.average(np.abs((q_xf - x_in)/(x_in+1e-20)))\n en = np.average(np.abs((q_xn - x_in)/(x_in+1e-20)))\n ec = np.average(np.abs((q_xc - x_in)/(x_in+1e-20)))\n enc = np.average(np.abs((q_xnc - x_in)/(x_in+1e-20)))\n print('average: ',layer_name, ef,en,ec,enc)\n\n fresults = np.append(fresults,ef)\n nresults = np.append(nresults,en)\n cresults = np.append(cresults,ec)\n ncresults = np.append(ncresults,enc)\n count += 1\n\n print(fresults)\n print(fresults.shape)\n nn = len(fresults)\n x = 1 + np.arange(0,nn)\n\n plt.figure()\n plt.tick_params(labelsize=10)\n ax=plt.gca()\n ax.xaxis.set_major_locator(ticker.MaxNLocator(integer=True))\n f, = plt.plot(x[1:], fresults[1:], alpha = 0.25, linewidth=3)\n n, = plt.plot(x[1:], nresults[1:], alpha = 0.5, linewidth=3)\n c, = plt.plot(x[1:], cresults[1:], alpha = 0.75, linewidth=3)\n nc, = plt.plot(x[1:],ncresults[1:],alpha = 1, linewidth=3)\n plt.legend([f,n,c,nc],['E_x=0', 'E_x=1', 'E_x=2','E_x=3'], prop={'size':12})\n plt.xlabel('layer id',{'size':15})\n plt.ylabel('average relative error',{'size':15})\n\n plt.savefig(data+'_'+epoch+'exp'+'.png')\n \n \ndef plotnc(data, epoch, man):\n f = h5py.File(prefix+data+'_'+epoch+'.h5','r')\n keys = f.keys()\n fresults = np.array([])\n nresults = np.array([])\n cresults = np.array([])\n ncresults = np.array([])\n count = 0\n for layer_name in keys:\n layer_data = f[layer_name][:]\n layer_name = layer_name[0:-8] if layer_name[-1]=='b' else layer_name[0:-6]\n if layer_name[0:-1].endswith('conv'):\n if count % 8 == 0:\n print(' ',layer_name)\n shape = layer_data.shape\n print(' shape',shape)\n print(' range',layer_data.min(), layer_data.max())\n x_in = torch.Tensor(layer_data)\n\n q_xf = Quantize_A.apply(x_in, \n man, \n 0, \n False, \n False, \n False, \n 'complex', \n 'progress')\n q_xn = Quantize_A.apply(x_in, \n man, \n 0, \n False, \n False, \n 'n', \n 'complex', \n 'progress')\n q_xc = Quantize_A.apply(x_in, \n man, \n 0, \n False, \n False, \n 'c', \n 'complex', \n 'progress')\n q_xnc = Quantize_A.apply(x_in, \n man, \n 0, \n False, \n False, \n 'nc', \n 'complex', \n 'progress')\n ef = np.average(np.abs((q_xf - x_in)/(x_in+1e-20)))\n en = np.average(np.abs((q_xn - x_in)/(x_in+1e-20)))\n ec = np.average(np.abs((q_xc - x_in)/(x_in+1e-20)))\n enc = np.average(np.abs((q_xnc - x_in)/(x_in+1e-20)))\n print('average: ',layer_name, ef,en,ec,enc)\n\n fresults = np.append(fresults,ef)\n nresults = np.append(nresults,en)\n cresults = np.append(cresults,ec)\n ncresults = np.append(ncresults,enc)\n count += 1\n\n print(fresults)\n print(fresults.shape)\n nn = len(fresults)\n x = 1+np.arange(0,nn)\n\n plt.figure()\n plt.tick_params(labelsize=10)\n ax=plt.gca()\n ax.xaxis.set_major_locator(ticker.MaxNLocator(integer=True))\n f, = plt.plot(x[1:], fresults[1:], alpha = 0.25, linewidth=3)\n n, = plt.plot(x[1:], nresults[1:], alpha = 0.5, linewidth=3)\n c, = plt.plot(x[1:], cresults[1:], alpha = 0.75, linewidth=3)\n nc, = plt.plot(x[1:],ncresults[1:],alpha = 1, linewidth=3)\n plt.legend([f,n,c,nc],['1 group', 'N groups', 'C groups','NxC groups'], prop={'size':12})\n plt.xlabel('layer id',{'size':15})\n plt.ylabel('average relative error',{'size':15})\n\n plt.savefig(data+'_'+epoch+'nc'+'.png')\n\n\ndef plotncexp(data, epoch, man):\n f = h5py.File(prefix+data+'_'+epoch+'.h5','r')\n keys = f.keys()\n fresults = np.array([])\n nresults = np.array([])\n cresults = np.array([])\n ncresults = np.array([])\n count = 0\n for layer_name in keys:\n layer_data = f[layer_name][:]\n layer_name = layer_name[0:-8] if layer_name[-1]=='b' else layer_name[0:-6]\n if layer_name[0:-1].endswith('conv'):\n if count % 8 == 0:\n print(' ',layer_name)\n shape = layer_data.shape\n print(' shape',shape)\n print(' range',layer_data.min(), layer_data.max())\n x_in = torch.Tensor(layer_data)\n\n q_xf = Quantize_A.apply(x_in, \n man, \n 0, \n False, \n False, \n 'nc', \n 'complex', \n 'progress')\n q_xn = Quantize_A.apply(x_in, \n man, \n 1, \n False, \n False, \n 'nc', \n 'complex', \n 'progress')\n q_xc = Quantize_A.apply(x_in, \n man, \n 2, \n False, \n False, \n 'nc', \n 'complex', \n 'progress')\n q_xnc = Quantize_A.apply(x_in, \n man, \n 3, \n False, \n False, \n 'nc', \n 'complex', \n 'progress')\n ef = np.average(np.abs((q_xf - x_in)/(x_in+1e-20)))\n en = np.average(np.abs((q_xn - x_in)/(x_in+1e-20)))\n ec = np.average(np.abs((q_xc - x_in)/(x_in+1e-20)))\n enc = np.average(np.abs((q_xnc - x_in)/(x_in+1e-20)))\n print('average: ',layer_name, ef,en,ec,enc)\n\n fresults = np.append(fresults,ef)\n nresults = np.append(nresults,en)\n cresults = np.append(cresults,ec)\n ncresults = np.append(ncresults,enc)\n count += 1\n\n print(fresults)\n print(fresults.shape)\n nn = len(fresults)\n x = np.arange(0,nn)\n\n plt.figure()\n plt.tick_params(labelsize=10)\n ax=plt.gca()\n ax.xaxis.set_major_locator(ticker.MaxNLocator(integer=True))\n f, = plt.plot(x[1:], fresults[1:], alpha = 0.25, linewidth=3)\n n, = plt.plot(x[1:], nresults[1:], alpha = 0.5, linewidth=3)\n c, = plt.plot(x[1:], cresults[1:], alpha = 0.75, linewidth=3)\n nc, = plt.plot(x[1:],ncresults[1:],alpha = 1, linewidth=3)\n plt.legend([f,n,c,nc],['E_x=0', 'E_x=1', 'E_x=2','E_x=3'], prop={'size':12})\n plt.xlabel('layer id',{'size':15})\n plt.ylabel('average relative error',{'size':15})\n\n plt.savefig(data+'_'+epoch+'ncexp'+'.png')\n\n \nplotnc('e',epochnum, mannum)\nplotexp('e', epochnum, mannum)\nplotncexp('e',epochnum, mannum)\n\nplotnc('a',epochnum, mannum)\nplotexp('a', epochnum, mannum)\nplotncexp('a',epochnum, mannum)\n\nplotnc('w',epochnum, mannum)\nplotexp('w', epochnum, mannum)\nplotncexp('w',epochnum, mannum)\n"
] |
[
[
"numpy.array",
"matplotlib.ticker.MaxNLocator",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.tick_params",
"numpy.arange",
"matplotlib.pyplot.ylabel",
"numpy.append",
"numpy.abs",
"matplotlib.pyplot.gca",
"torch.Tensor"
]
] |
tnakaicode/python-cfd
|
[
"174176bdcb1c31e021fefd8fd54e2b3dd898dc62"
] |
[
"lessons_src/13_Step_10.py"
] |
[
"#!/usr/bin/env python\n# coding: utf-8\n# # Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved BSD-3 license. (c) Lorena A. Barba, Gilbert F. Forsyth 2017. Thanks to NSF for support via CAREER award #1149784.\n# [@LorenaABarba](https://twitter.com/LorenaABarba)\n\n# 12 steps to Navier–Stokes\n# =====\n# ***\n\n# For a moment, recall the Navier–Stokes equations for an incompressible fluid, where $\\vec{v}$ represents the velocity field:\n#\n# $$\n# \\begin{eqnarray*}\n# \\nabla \\cdot\\vec{v} &=& 0 \\\\\n# \\frac{\\partial \\vec{v}}{\\partial t}+(\\vec{v}\\cdot\\nabla)\\vec{v} &=& -\\frac{1}{\\rho}\\nabla p + \\nu \\nabla^2\\vec{v}\n# \\end{eqnarray*}\n# $$\n#\n# The first equation represents mass conservation at constant density. The second equation is the conservation of momentum. But a problem appears: the continuity equation for incompressble flow does not have a dominant variable and there is no obvious way to couple the velocity and the pressure. In the case of compressible flow, in contrast, mass continuity would provide an evolution equation for the density $\\rho$, which is coupled with an equation of state relating $\\rho$ and $p$.\n#\n# In incompressible flow, the continuity equation $\\nabla \\cdot\\vec{v}=0$ provides a *kinematic constraint* that requires the pressure field to evolve so that the rate of expansion $\\nabla \\cdot\\vec{v}$ should vanish everywhere. A way out of this difficulty is to *construct* a pressure field that guarantees continuity is satisfied; such a relation can be obtained by taking the divergence of the momentum equation. In that process, a Poisson equation for the pressure shows up!\n\n# Step 10: 2D Poisson Equation\n# ----\n# ***\n\n# Poisson's equation is obtained from adding a source term to the right-hand-side of Laplace's equation:\n#\n# $$\\frac{\\partial ^2 p}{\\partial x^2} + \\frac{\\partial ^2 p}{\\partial y^2} = b$$\n#\n# So, unlinke the Laplace equation, there is some finite value inside the field that affects the solution. Poisson's equation acts to \"relax\" the initial sources in the field.\n#\n# In discretized form, this looks almost the same as [Step 9](./12_Step_9.ipynb), except for the source term:\n#\n# $$\\frac{p_{i+1,j}^{n}-2p_{i,j}^{n}+p_{i-1,j}^{n}}{\\Delta x^2}+\\frac{p_{i,j+1}^{n}-2 p_{i,j}^{n}+p_{i,j-1}^{n}}{\\Delta y^2}=b_{i,j}^{n}$$\n#\n# As before, we rearrange this so that we obtain an equation for $p$ at point $i,j$. Thus, we obtain:\n#\n# $$p_{i,j}^{n}=\\frac{(p_{i+1,j}^{n}+p_{i-1,j}^{n})\\Delta y^2+(p_{i,j+1}^{n}+p_{i,j-1}^{n})\\Delta x^2-b_{i,j}^{n}\\Delta x^2\\Delta y^2}{2(\\Delta x^2+\\Delta y^2)}$$\n#\n\n# We will solve this equation by assuming an initial state of $p=0$ everywhere, and applying boundary conditions as follows:\n#\n# $p=0$ at $x=0, \\ 2$ and $y=0, \\ 1$\n#\n# and the source term consists of two initial spikes inside the domain, as follows:\n#\n# $b_{i,j}=100$ at $i=\\frac{1}{4}nx, j=\\frac{1}{4}ny$\n#\n# $b_{i,j}=-100$ at $i=\\frac{3}{4}nx, j=\\frac{3}{4}ny$\n#\n# $b_{i,j}=0$ everywhere else.\n#\n# The iterations will advance in pseudo-time to relax the initial spikes. The relaxation under Poisson's equation gets slower and slower as they progress. *Why?*\n\n# Let's look at one possible way to write the code for Poisson's equation. As always, we load our favorite Python libraries. We also want to make some lovely plots in 3D. Let's get our parameters defined and the initialization out of the way. What do you notice of the approach below?\n\n# In[1]:\n\n\nimport numpy\nfrom matplotlib import pyplot, cm\nfrom mpl_toolkits.mplot3d import Axes3D\n## get_ipython().run_line_magic('matplotlib', 'inline')\n\n\n# In[2]:\n\n\n# Parameters\nnx = 50\nny = 50\nnt = 100\nxmin = 0\nxmax = 2\nymin = 0\nymax = 1\n\ndx = (xmax - xmin) / (nx - 1)\ndy = (ymax - ymin) / (ny - 1)\n\n# Initialization\np = numpy.zeros((ny, nx))\npd = numpy.zeros((ny, nx))\nb = numpy.zeros((ny, nx))\nx = numpy.linspace(xmin, xmax, nx)\ny = numpy.linspace(xmin, xmax, ny)\n\n# Source\nb[int(ny / 4), int(nx / 4)] = 100\nb[int(3 * ny / 4), int(3 * nx / 4)] = -100\n\n\n# With that, we are ready to advance the initial guess in pseudo-time. How is the code below different from the function used in [Step 9](./12_Step_9.ipynb) to solve Laplace's equation?\n\n# In[3]:\n\n\nfor it in range(nt):\n\n pd = p.copy()\n\n p[1:-1, 1:-1] = (((pd[1:-1, 2:] + pd[1:-1, :-2]) * dy**2 +\n (pd[2:, 1:-1] + pd[:-2, 1:-1]) * dx**2 -\n b[1:-1, 1:-1] * dx**2 * dy**2) /\n (2 * (dx**2 + dy**2)))\n\n p[0, :] = 0\n p[ny - 1, :] = 0\n p[:, 0] = 0\n p[:, nx - 1] = 0\n\n\n# Maybe we could reuse our plotting function from [Step 9](./12_Step_9.ipynb), don't you think?\n\n# In[4]:\n\n\ndef plot2D(x, y, p):\n fig = pyplot.figure(figsize=(11, 7), dpi=100)\n ax = fig.gca(projection='3d')\n X, Y = numpy.meshgrid(x, y)\n surf = ax.plot_surface(X, Y, p[:], rstride=1, cstride=1, cmap=cm.viridis,\n linewidth=0, antialiased=False)\n ax.view_init(30, 225)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$')\n\n\n# In[5]:\n\n\nplot2D(x, y, p)\npyplot.show()\n\n# Ah! The wonders of code reuse! Now, you probably think: \"Well, if I've written this neat little function that does something so useful, I want to use it over and over again. How can I do this without copying and pasting it each time? —If you are very curious about this, you'll have to learn about *packaging*. But this goes beyond the scope of our CFD lessons. You'll just have to Google it if you really want to know.\n\n# ***\n\n# ## Learn More\n\n# To learn more about the role of the Poisson equation in CFD, watch **Video Lesson 11** on You Tube:\n\n# In[6]:\n\n\n#from IPython.display import YouTubeVideo\n# YouTubeVideo('ZjfxA3qq2Lg')\n\n\n# In[7]:\n\n\n#from IPython.core.display import HTML\n# def css_styling():\n# styles = open(\"../styles/custom.css\", \"r\").read()\n# return HTML(styles)\n# css_styling()\n\n\n# > (The cell above executes the style for this notebook.)\n"
] |
[
[
"numpy.zeros",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.show",
"numpy.linspace",
"numpy.meshgrid"
]
] |
My-UIT-Students/VIPUsingFPGA
|
[
"e4afadb8def58f0c956c5399a6e9003a15ec43e8"
] |
[
"CNNs/lenet/main.py"
] |
[
"import torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.nn.functional as F\nimport torch.backends.cudnn as cudnn\nfrom lenet import *\nWEIGHT_PATH = './weights/'\ndevice = 'cuda' if torch.cuda.is_available() else 'cpu'\n\nnet = LeNet(WEIGHT_PATH)\n\nif device == 'cuda':\n net = torch.nn.DataParallel(net)\n cudnn.benchmark = True\n\nnet = net.to(device)\ncheckpoint = torch.load(WEIGHT_PATH + 'lenet.pth',map_location=device)\nnet.load_state_dict(checkpoint['net'])\n# print(net.eval())\n# net.load_state_dic()\ndata = torch.randn([1,3,32,32],dtype=torch.float32)\ndata = data.to(device)\nnet.module.export_weights()\nout = net.module.conv1(data)\n\nprint(out)"
] |
[
[
"torch.cuda.is_available",
"torch.randn",
"torch.load",
"torch.nn.DataParallel"
]
] |
puyamirkarimi/quantum-walks
|
[
"eb41146cc22e32b2f4d5a6119cc892f45062764c",
"eb41146cc22e32b2f4d5a6119cc892f45062764c",
"eb41146cc22e32b2f4d5a6119cc892f45062764c"
] |
[
"Max2SAT_quantum/plot_av_inf_time_prob_n.py",
"Max2SAT/mixsat_runner.py",
"Max2SAT/mixsat_runtime_plot_compare.py"
] |
[
"import numpy as np\nimport matplotlib.pyplot as plt\n\n\ndef plot_graph(x, y, fit):\n plt.figure()\n plt.scatter(x, y)\n if fit is not None:\n plt.plot(x, fit, '--')\n plt.tick_params(direction='in', top=True, right=True)\n plt.xlim(5, 9)\n plt.ylim(2, 16)\n plt.xticks(range(5, 10, 1))\n # plt.yticks(range(start, end+1, step))\n plt.xlabel(\"$n$\")\n plt.ylabel(r\"$1 / \\langle P_{\\infty} \\rangle$\")\n plt.yscale('log', basey=2)\n plt.show()\n\n\ndef fit_and_plot(x_array, y_array):\n m_log, c_log = np.polyfit(x_array[0:], np.log2(y_array), 1, w=np.sqrt(y_array))\n exp_fit = np.exp2(m_log * x_array + c_log)\n print(str(np.exp2(c_log))+\" * 2^(\" + str(m_log) + \" * n)\")\n plot_graph(x_array, y_array, exp_fit)\n\n\nif __name__ == '__main__':\n plt.rc('text', usetex=True)\n plt.rc('font', size=14)\n\n n_array = np.array([5, 6, 7, 8])\n av_probs = np.zeros(len(n_array))\n\n for i, n in enumerate(n_array):\n probs = np.loadtxt(\"inf_time_probs_n_\" + str(n) + \".txt\")\n av_probs[i] = 1/np.mean(probs)\n\n fit_and_plot(n_array, av_probs)\n",
"import subprocess\nimport time\nimport numpy as np\n\n\ndef get_instances():\n \"\"\"returns array of instance names, array of corresponding n\"\"\"\n instance_data = np.genfromtxt('m2s_nqubits.csv', delimiter=',', skip_header=1, dtype=str) # can add _noGT_nondg on end\n return instance_data[:, 0], instance_data[:, 1]\n\n\nif __name__ == '__main__':\n instance_names, instance_n_bits_str = get_instances()\n # qubits_array = np.array(range(5, 21)) # Adam's instances range from n=5 to n=20\n runtimes = np.zeros(10000)\n states_count = np.zeros(10000)\n\n n = 20\n n_shifted = n-5 # n_shifted runs from 0 to 15 instead of 5 to 20\n\n for loop, i in enumerate(range(n_shifted*10000, (n_shifted+1)*10000)): # 10000 instances per value of n\n instance_name = instance_names[i]\n time_start_inst = time.time()\n result = subprocess.run(['./../../mixsat/complete', './../../instances_dimacs/'+instance_name+'.txt'], stdout=subprocess.PIPE) # can add _noGT_nondg on end\n time_end_inst = time.time()\n runtime = time_end_inst - time_start_inst\n runtimes[loop] = runtime\n output = str(result.stdout)\n\n string_start_index = output.find('state_visited ') + 14\n string_end_index = output.find(' pruned')\n states_visited = int(output[string_start_index: string_end_index])\n states_count[loop] = states_visited\n\n with open(\"adam_runtimes_\"+str(n)+\".txt\", \"ab\") as f: # saves runtimes using time.time() # can add _noGT_nondg in middle\n f.write(b\"\\n\")\n np.savetxt(f, runtimes)\n\n with open(\"adam_counts_\"+str(n)+\".txt\", \"ab\") as f: # saves counts # can add _noGT_nondg in middle\n f.write(b\"\\n\")\n np.savetxt(f, states_count)\n",
"import matplotlib.pyplot as plt\nimport numpy as np\n\n\ndef average_data(data):\n num_repeats = len(data[:, 0])\n num_x_vals = len(data[0, :])\n y_av = np.zeros(num_x_vals)\n y_std_error = np.zeros(num_x_vals)\n\n for x in range(num_x_vals):\n y_av[x] = np.mean(data[:, x])\n y_std_error[x] = np.std(data[:, x], ddof=1) / np.sqrt(num_repeats)\n\n return y_av, y_std_error\n\n\n# def plot_graph(x, y, y_std_error, fit_1, fit_2):\n# fig, ax = plt.subplots()\n# plt.scatter(x[4:], y[4:])\n# plt.scatter(x[:4], y[:4], color=\"gray\")\n# plt.plot(x, fit_1, '--', label=\"$y=0.0005x + 0.0012$\", color=\"red\")\n# plt.plot(x, fit_2, label=r\"$y=0.0036 \\times 2^{0.0871x}$\", color=\"green\")\n# #plt.errorbar(x, y, y_std_error)\n# ax.set_xlabel(\"Number of variables, $n$\")\n# ax.set_ylabel(\"Average runtime ($s$)\")\n# ax.set_xlim([5, 20])\n# ax.set_xticks(range(5, 21, 3))\n# ax.set_ylim([0.004, 0.012])\n# ax.set_yscale('log')\n# plt.legend()\n# plt.tight_layout()\n# plt.show()\n\n\ndef zero_to_nan(array):\n \"\"\"Replace every 0 with 'nan' and return a copy.\"\"\"\n return [float('nan') if x==0 else x for x in array]\n\n\ndef counts_data_crosson():\n counts_crosson = np.loadtxt(\"crosson_counts.txt\").reshape((-1, 137))\n return average_data(counts_crosson)\n\n\ndef runtimes_data_crosson():\n runtimes_crosson = np.loadtxt(\"crosson_runtimes.txt\").reshape((-1, 137))\n return average_data(runtimes_crosson)\n\n\ndef counts_data_adam(n):\n counts_adam = np.loadtxt(\"adam_counts_\"+str(n)+\".txt\").reshape((-1, 10000))\n return average_data(counts_adam)\n\n\ndef runtimes_data_adam(n):\n runtimes_adam = np.loadtxt(\"adam_runtimes_\"+str(n)+\".txt\").reshape((-1, 10000))\n return average_data(runtimes_adam)\n\n\ndef counts_data_adam_noGT(n):\n counts_adam = np.loadtxt(\"adam_noGT_counts_\"+str(n)+\".txt\").reshape((-1, 10000))\n return average_data(counts_adam)\n\n\ndef runtimes_data_adam_noGT(n):\n runtimes_adam = np.loadtxt(\"adam_noGT_runtimes_\"+str(n)+\".txt\").reshape((-1, 10000))\n return average_data(runtimes_adam)\n\n\ndef counts_data_adam_noGT_nondg(n):\n counts_adam = np.loadtxt(\"adam_noGT_nondg_counts_\"+str(n)+\".txt\").reshape((-1, 10000))\n return average_data(counts_adam)\n\n\ndef runtimes_data_adam_noGT_nondg(n):\n runtimes_adam = np.loadtxt(\"adam_noGT_nondg_runtimes_\"+str(n)+\".txt\").reshape((-1, 10000))\n return average_data(runtimes_adam)\n\n\nif __name__ == '__main__':\n plt.rc('text', usetex=True)\n plt.rc('font', size=10)\n\n n_list = [9]\n counts_list_adam = []\n runtimes_list_adam = []\n colors = ['blue', 'orange', 'green']\n\n ################## COUNTS ##################\n counts_crosson_average, counts_crosson_standard_error = counts_data_crosson()\n min_count = np.min(counts_crosson_average)\n max_count = np.max(counts_crosson_average)\n\n for n in n_list:\n counts_adam_average, counts_adam_standard_error = counts_data_adam(n)\n counts_list_adam.append(counts_adam_average)\n min_count_temp = np.min(counts_adam_average)\n max_count_temp = np.max(counts_adam_average)\n if min_count_temp < min_count:\n min_count = min_count_temp\n if max_count_temp > max_count:\n max_count = max_count_temp\n\n for n in n_list:\n counts_adam_average, counts_adam_standard_error = counts_data_adam_noGT(n)\n counts_list_adam.append(counts_adam_average)\n min_count_temp = np.min(counts_adam_average)\n max_count_temp = np.max(counts_adam_average)\n if min_count_temp < min_count:\n min_count = min_count_temp\n if max_count_temp > max_count:\n max_count = max_count_temp\n\n for n in n_list:\n counts_adam_average, counts_adam_standard_error = counts_data_adam_noGT_nondg(n)\n counts_list_adam.append(counts_adam_average)\n min_count_temp = np.min(counts_adam_average)\n max_count_temp = np.max(counts_adam_average)\n if min_count_temp < min_count:\n min_count = min_count_temp\n if max_count_temp > max_count:\n max_count = max_count_temp\n\n x = np.arange(np.floor(min_count), np.ceil(max_count)+1)\n y_adam = np.zeros((len(n_list)*3, len(x)))\n y_crosson = np.zeros(len(x))\n\n for i, count in enumerate(x):\n for i_adam in range(len(n_list)*3):\n y_adam[i_adam, i] = np.count_nonzero(counts_list_adam[i_adam] == count) / 10000 # division by 10000 is to normalise\n y_crosson[i] = np.count_nonzero(counts_crosson_average == count) / 137\n\n for i_adam in range(len(n_list)*3):\n y_adam[i_adam] = zero_to_nan(y_adam[i_adam]) # replace zero elements in list with NaN so they aren't plotted\n\n y_crosson = zero_to_nan(y_crosson)\n\n fig1, ax1 = plt.subplots()\n for i_adam, n in enumerate(n_list):\n plt.scatter(x, y_adam[i_adam], label=\"n=\"+str(n)+\" transformed\", marker='+')\n for i_adam, n in enumerate(n_list):\n plt.scatter(x, y_adam[i_adam+len(n_list)], label=\"n=\"+str(n)+\" untransformed\", marker='+')\n for i_adam, n in enumerate(n_list):\n plt.scatter(x, y_adam[i_adam+2*len(n_list)], label=\"n=\"+str(n)+\" untransformed, degen\", marker='+')\n #plt.scatter(x, y_crosson, label=\"n=20 (Crosson)\")\n #plt.errorbar(x, counts_average, counts_standard_error)\n plt.xlim([0, max_count])\n #plt.ylim([0, 0.3])\n plt.yscale('log')\n plt.legend()\n plt.xlabel(\"Number of states visited by MIXSAT algorithm\")\n plt.ylabel(\"Number of instances (normalised)\")\n plt.show()\n\n ################## RUNTIMES ##################\n runtimes_crosson_average, runtimes_crosson_standard_error = runtimes_data_crosson()\n runtimes_crosson_average = np.around(runtimes_crosson_average, 4) # binning\n min_runtime = np.min(runtimes_crosson_average)\n max_runtime = np.max(runtimes_crosson_average)\n\n for n in n_list:\n runtimes_adam_average, runtimes_adam_standard_error = runtimes_data_adam(n)\n runtimes_adam_average = np.around(runtimes_adam_average, 5) # binning\n runtimes_list_adam.append(runtimes_adam_average)\n min_runtime_temp = np.min(runtimes_adam_average)\n max_runtime_temp = np.max(runtimes_adam_average)\n if min_runtime_temp < min_runtime:\n min_runtime = min_runtime_temp\n if max_runtime_temp > max_runtime:\n max_runtime = max_runtime_temp\n\n for n in n_list:\n runtimes_adam_average, runtimes_adam_standard_error = runtimes_data_adam_noGT(n)\n runtimes_adam_average = np.around(runtimes_adam_average, 5) # binning\n runtimes_list_adam.append(runtimes_adam_average)\n min_runtime_temp = np.min(runtimes_adam_average)\n max_runtime_temp = np.max(runtimes_adam_average)\n if min_runtime_temp < min_runtime:\n min_runtime = min_runtime_temp\n if max_runtime_temp > max_runtime:\n max_runtime = max_runtime_temp\n\n for n in n_list:\n runtimes_adam_average, runtimes_adam_standard_error = runtimes_data_adam_noGT_nondg(n)\n runtimes_adam_average = np.around(runtimes_adam_average, 5) # binning\n runtimes_list_adam.append(runtimes_adam_average)\n min_runtime_temp = np.min(runtimes_adam_average)\n max_runtime_temp = np.max(runtimes_adam_average)\n if min_runtime_temp < min_runtime:\n min_runtime = min_runtime_temp\n if max_runtime_temp > max_runtime:\n max_runtime = max_runtime_temp\n\n x = np.arange(np.floor(min_runtime), np.ceil(max_runtime) + 1, step=0.00001)\n x_crosson = np.arange(np.floor(min_runtime), np.ceil(max_runtime) + 1, step=0.0001)\n y_adam = np.zeros((len(n_list)*3, len(x)))\n y_crosson = np.zeros(len(x_crosson))\n\n for i, runtime in enumerate(x):\n for i_adam in range(len(n_list)*3):\n y_adam[i_adam, i] = np.count_nonzero(runtimes_list_adam[i_adam] == runtime) / 10000 # division by 10000 is to normalise\n for i, runtime in enumerate(x_crosson):\n y_crosson[i] = np.count_nonzero(runtimes_crosson_average == runtime) / 1370\n\n for i_adam in range(len(n_list)*3):\n y_adam[i_adam] = zero_to_nan(y_adam[i_adam]) # replace zero elements in list with NaN so they aren't plotted\n\n y_crosson = zero_to_nan(y_crosson)\n\n fig2, ax2 = plt.subplots()\n for i_adam, n in enumerate(n_list):\n plt.scatter(x, y_adam[i_adam], label=\"n=\"+str(n)+\" transformed\", marker='+')\n for i_adam, n in enumerate(n_list):\n plt.scatter(x, y_adam[i_adam+len(n_list)], label=\"n=\" + str(n)+\" untransformed\", marker='+')\n for i_adam, n in enumerate(n_list):\n plt.scatter(x, y_adam[i_adam+2*len(n_list)], label=\"n=\" + str(n)+\" untransformed, degen\", marker='+')\n #plt.scatter(x_crosson, y_crosson, label=\"n=20 (Crosson)\")\n # plt.errorbar(x, runtimes_average, runtimes_standard_error)\n plt.xlim([0, max_runtime])\n # plt.ylim([0, 0.3])\n plt.yscale('log')\n plt.xlabel(\"Rounded runtime of MIXSAT algorithm\")\n plt.ylabel(\"Number of instances (normalised)\")\n plt.legend()\n plt.show()\n\n"
] |
[
[
"numpy.array",
"matplotlib.pyplot.xlim",
"numpy.exp2",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.plot",
"numpy.mean",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.tick_params",
"matplotlib.pyplot.rc",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"numpy.sqrt",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.yscale",
"numpy.log2"
],
[
"numpy.genfromtxt",
"numpy.savetxt",
"numpy.zeros"
],
[
"matplotlib.pyplot.xlim",
"numpy.min",
"numpy.mean",
"numpy.max",
"numpy.count_nonzero",
"matplotlib.pyplot.subplots",
"numpy.sqrt",
"numpy.around",
"matplotlib.pyplot.yscale",
"numpy.zeros",
"matplotlib.pyplot.rc",
"numpy.std",
"numpy.loadtxt",
"matplotlib.pyplot.show",
"numpy.floor",
"numpy.ceil",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel"
]
] |
syybata/tf_dqn_fx
|
[
"71061f0c0bb15d647a13d3e2c0d549a5c2d1780a"
] |
[
"tensorboard_sample.py"
] |
[
"import tensorflow as tf\n\ncross_entropy = tf.placeholder(tf.float32)\n\n# sessionの用意\nsess = tf.Session()\ntf.global_variables_initializer().run(session=sess)\n#sess.run(tf.global_variables_initializer())\n\n# summaryの設定\ntf.summary.scalar('cross_entropy', cross_entropy)\nsummaries = tf.summary.merge_all()\ntrain_writer = tf.summary.FileWriter('shiba_train', sess.graph)\n\n# 100回実行してcross_entropyのsummaryを記録\nfor step in range(100):\n summary_str = sess.run(summaries, {cross_entropy: step})\n train_writer.add_summary(summary_str, step)\n"
] |
[
[
"tensorflow.summary.scalar",
"tensorflow.Session",
"tensorflow.placeholder",
"tensorflow.summary.merge_all",
"tensorflow.summary.FileWriter",
"tensorflow.global_variables_initializer"
]
] |
JoseAlanis/supplementary_dpx_tt
|
[
"2b5a94c35753dc9dbf51357c840a87380e40fe3c",
"2b5a94c35753dc9dbf51357c840a87380e40fe3c"
] |
[
"bads.py",
"mvpa_stats.py"
] |
[
"\"\"\"\n=================\nFind bad channels\n=================\n\nMethods for finding bad (e.g., noisy) channels in EEG data.\n\nAuthors: José C. García Alanis <alanis.jcg@gmail.com>\n\nLicense: BSD (3-clause)\n\"\"\"\nimport warnings\n\nimport numpy as np\nfrom scipy.stats import median_abs_deviation as mad\n\nfrom mne.io.base import BaseRaw\n\n\n# main function which implements different methods\ndef find_bad_channels(inst, picks='eeg',\n method='correlation',\n mad_threshold=1,\n std_threshold=1,\n r_threshold=0.4,\n percent_threshold=0.1,\n time_step=1.0,\n sfreq=None,\n return_z_scores=False,\n channels=None):\n\n # arguments to be passed to pick_types\n kwargs = {pick: True for pick in [picks]}\n\n # check that tha input data can be handled by the function\n if isinstance(inst, BaseRaw):\n # only keep data from desired channels\n inst = inst.copy().pick_types(**kwargs)\n dat = inst.get_data() * 1e6 # to microvolt\n channels = inst.ch_names\n sfreq = inst.info['sfreq']\n elif isinstance(inst, np.ndarray):\n dat = inst\n if not channels:\n raise ValueError('If \"inst\" is not an instance of BaseRaw a list '\n 'of channel names must be provided')\n else:\n raise ValueError('inst must be an instance of BaseRaw or a numpy array')\n\n # save shape of data\n n_channels, n_samples = dat.shape\n if n_channels != len(channels):\n raise ValueError(\"Number and channels and data dimensions don't match\")\n\n # make sure method arguments are in a list\n if not isinstance(method, list):\n method = [method]\n\n # place holder for results\n bad_channels = dict()\n\n # 1) find channels with zero or near zero activity\n if 'flat' in method:\n # compute estimates of channel activity\n mad_flats = mad(dat, scale=1, axis=1) < mad_threshold\n std_flats = np.std(dat, axis=1) < std_threshold\n\n # flat channels identified\n flats = np.argwhere(np.logical_or(mad_flats, std_flats))\n flats = np.asarray([channels[int(flat)] for flat in flats])\n\n # warn user if too many channels were identified as flat\n if flats.shape[0] > (n_channels / 2):\n warnings.warn('Too many channels have been identified as \"flat\"! '\n 'Make sure the input values in \"inst\" are provided '\n 'on a volt scale. '\n 'Otherwise try choosing another (meaningful) '\n 'threshold for identification.')\n\n bad_channels.update(flat=flats)\n\n # 3) find bad channels by deviation (high variability in amplitude)\n if 'deviation' in method:\n\n # mean absolute deviation (MAD) scores for each channel\n mad_scores = \\\n [mad(dat[i, :], scale=1) for i in range(n_channels)]\n\n # compute robust z-scores for each channel\n rz_scores = \\\n 0.6745 * (mad_scores - np.nanmedian(mad_scores)) / mad(mad_scores,\n scale=1)\n\n # channels identified by deviation criterion\n bad_deviation = \\\n [channels[i] for i in np.where(np.abs(rz_scores) >= 5.0)[0]]\n\n bad_channels.update(deviation=np.asarray(bad_deviation))\n\n if return_z_scores:\n bad_channels.update(deviation_z_scores=rz_scores)\n\n # 3) find channels with low correlation to other channels\n if 'correlation' in method:\n\n # check that sampling frequency argument was provided\n if not sfreq:\n raise ValueError('If \"inst\" is not an instance of BaseRaw a '\n 'sampling frequency must be provided. Usually '\n 'the sampling frequency of the EEG recording in'\n 'question.')\n\n # based on the length of the provided data,\n # determine size and amount of time windows for analyses\n corr_frames = time_step * sfreq\n corr_window = np.arange(corr_frames)\n\n # sample index (i.e., time offsets) for each window to time window\n # to use for correlation analyis\n corr_offsets = np.arange(1, (n_samples - corr_frames), corr_frames)\n n_corr_steps = corr_offsets.shape[0]\n # place holders for correlation coefficients\n max_r = np.ones((n_channels, n_corr_steps))\n channel_r = np.ones((n_corr_steps, n_channels))\n\n # create time windows for analysis\n dat_t = np.transpose(dat)\n dat_windowed = np.reshape(\n np.transpose(dat_t[0: corr_window.shape[0] * n_corr_steps, :]),\n (n_channels, corr_window.shape[0], n_corr_steps),\n order=\"F\",)\n\n # compute (pearson) correlation coefficient across channels\n # (for each channel and analysis time window)\n # take the absolute of the 98th percentile of the correlations with\n # the other channels as a measure of how well that channel is correlated\n # to other channels\n for k in range(0, n_corr_steps):\n eeg_portion = np.transpose(np.squeeze(dat_windowed[:, :, k]))\n window_correlation = np.corrcoef(np.transpose(eeg_portion))\n abs_corr = \\\n np.abs(\n np.subtract(\n window_correlation, np.diag(np.diag(window_correlation))\n )\n )\n channel_r[k, :] = np.quantile(abs_corr, 0.98, axis=0)\n\n # fill in the actual correlations\n max_r[np.arange(0, n_channels), :] = np.transpose(channel_r)\n\n # check which channels correlate badly with the other channels (i.e.,\n # are below correlation threshold) in a certain fraction of windows\n # (bad_time_threshold)\n thresholded_correlations = max_r < r_threshold\n thresholded_correlations = thresholded_correlations.astype(int)\n frac_bad_corr_windows = np.mean(thresholded_correlations, axis=1)\n\n # find the corresponding channel names and return\n bad_idxs = np.argwhere(frac_bad_corr_windows > percent_threshold)\n uncorrelated_channels = [channels[int(bad)] for bad in bad_idxs]\n\n bad_channels.update(correlation=np.asarray(uncorrelated_channels)) # noqa: E501\n\n return bad_channels\n",
"\"\"\"\n==============\nMVPA functions\n==============\n\nUtility functions for estimation and statistical analysis of MVPA parameters.\n\nAuthors: Functions retrieved and adapted from\n https://github.com/heikele/GAT_n4-p6, also see:\n Heikel, E., Sassenhagen, J., & Fiebach, C. J. (2018).\n Time-generalized multivariate analysis of EEG responses reveals a\n cascading architecture of semantic mismatch processing.\n Brain and language, 184, 43-53.\n Changes made by José C. García Alanis <alanis.jcg@gmail.com>\n\nLicense: BSD (3-clause)\n\"\"\"\nimport numpy as np\n\nimport matplotlib.pyplot as plt\n\nimport pandas as pd\n\nfrom scipy.stats import wilcoxon\n\nfrom sklearn.linear_model import RidgeClassifier, LogisticRegression\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.svm import SVC\n\nfrom mne.decoding import cross_val_multiscore, GeneralizingEstimator, \\\n get_coef, Vectorizer\nfrom mne.parallel import parallel_func\nfrom mne.stats import fdr_correction, spatio_temporal_cluster_1samp_test, \\\n ttest_1samp_no_p\nfrom mne import read_epochs\n\nfrom config import fname\n\n\n# signed rank test\ndef _my_wilcoxon(X):\n out = wilcoxon(X)\n return out[1]\n\n\n# loop function\ndef _loop(x, function):\n out = list()\n for ii in range(x.shape[1]):\n out.append(function(x[:, ii]))\n return out\n\n\n# correct p values for multiple testing\ndef parallel_stats(X, function=_my_wilcoxon, correction='FDR', n_jobs=2):\n\n # check if correction method was provided\n if correction not in [False, None, 'FDR']:\n raise ValueError('Unknown correction')\n\n # reshape to 2D\n X = np.array(X)\n dims = X.shape\n X.resize([dims[0], np.prod(dims[1:])])\n\n # prepare parallel\n n_cols = X.shape[1]\n parallel, pfunc, n_jobs = parallel_func(_loop, n_jobs)\n n_chunks = min(n_cols, n_jobs)\n chunks = np.array_split(range(n_cols), n_chunks)\n p_values = parallel(pfunc(X[:, chunk], function) for chunk in chunks)\n p_values = np.reshape(np.hstack(p_values), dims[1:])\n X.resize(dims)\n\n # apply correction\n if correction == 'FDR':\n dims = p_values.shape\n _, p_values = fdr_correction(p_values)\n p_values = np.reshape(p_values, dims)\n\n return p_values\n\n\n# one sample t-test\ndef _stat_fun(x, sigma=0, method='relative'):\n t_values = ttest_1samp_no_p(x, sigma=sigma, method=method)\n t_values[np.isnan(t_values)] = 0\n return t_values\n\n\n# threshold free cluster permutation test\ndef stats_tfce(X, n_permutations=1000, threshold=None, n_jobs=2):\n\n # calculate p-values using cluster permutation test\n _, _, p_values, _ = spatio_temporal_cluster_1samp_test(\n X,\n out_type='indices',\n stat_fun=_stat_fun,\n n_permutations=n_permutations,\n threshold=threshold,\n n_jobs=n_jobs)\n\n p_values = p_values.reshape(X.shape[1:])\n\n return p_values\n\n\n# function to import mne-epochs for participant\ndef get_epochs(subj):\n \"\"\"\n Loads the single trial data for a participant (name)\n \"\"\"\n\n input_file = fname.output(subject=subj,\n processing_step='cue_epochs',\n file_type='epo.fif')\n epoch = read_epochs(input_file)\n epoch.crop(tmin=-0.5, tmax=epoch.tmax, include_tmax=False)\n epoch.apply_baseline((-0.300, -0.050))\n\n return epoch\n\n\n# run generalisation across time and condition\ndef run_gat(subj, decoder=\"ridge\", n_jobs=2):\n \"\"\"\n Function to run Generalization Across Time (GAT).\n\n Parameters\n ----------\n subj: int\n decoder: str\n Specify type of classifier -'ridge' for Ridge Regression (default),\n 'lin-svm' for linear SVM 'svm' for nonlinear (RBF) SVM and 'log_reg'\n for Logistic Regression\n n_jobs: int\n The number of jobs to run in parallel.\n \"\"\"\n # load cue A and cue B epochs\n epochs = get_epochs(subj)['Correct A', 'Correct B']\n\n # specify whether to use a linear or nonlinear SVM if SVM is used\n lin = '' # if not svm it doesn't matter, both log_reg and ridge are linear\n if \"svm\" in decoder:\n decoder, lin = decoder.split(\"-\")\n\n # build classifier pipeline #\n # pick a machine learning algorithm to use (ridge/SVM/logistic regression)\n decoder_dict = {\n \"ridge\": RidgeClassifier(class_weight='balanced',\n random_state=42,\n solver=\"sag\"),\n \"svm\": SVC(class_weight='balanced',\n kernel=(\"rbf\" if \"non\" in lin else \"linear\"),\n random_state=42),\n \"log_reg\": LogisticRegression(class_weight='balanced',\n random_state=42)}\n\n # get data and targets\n data = epochs.get_data()\n labels = epochs.events[:, -1]\n\n # create classifier pipeline\n clf = make_pipeline(StandardScaler(),\n decoder_dict[decoder])\n gen_clf = GeneralizingEstimator(clf, scoring=\"roc_auc\", n_jobs=n_jobs)\n\n # compute cross validated performance scores\n scores = cross_val_multiscore(gen_clf, data,\n labels,\n cv=5,\n n_jobs=n_jobs).mean(0)\n\n # calculate prediction confidence scores\n cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n preds = np.empty((len(labels), data.shape[2], data.shape[2]))\n for train, test in cv.split(data, labels):\n gen_clf.fit(data[train], labels[train])\n d = gen_clf.decision_function(data[test])\n preds[test] = d\n\n # compute topographical patterns\n dat = Vectorizer().fit_transform(data)\n clf.fit(dat, labels)\n dat = dat - dat.mean(0, keepdims=True)\n\n # look for the type of classifier and get the weights\n if decoder == 'ridge':\n filt_ = clf.named_steps.ridgeclassifier.coef_.copy()\n elif decoder == 'svm':\n filt_ = clf.named_steps.svc.coef_.copy()\n elif decoder == 'log_reg':\n filt_ = clf.named_steps.logisticregression.coef_.copy()\n\n # Compute patterns using Haufe's trick: A = Cov_X . W . Precision_Y\n # cf.Haufe, et al., 2014, NeuroImage,\n # doi:10.1016/j.neuroimage.2013.10.067)\n inv_y = 1.\n patt_ = np.cov(dat.T).dot(filt_.T.dot(inv_y)).T\n\n # store the patterns accordingly\n if decoder == 'ridge':\n clf.named_steps.ridgeclassifier.patterns_ = patt_\n elif decoder == 'svm':\n clf.named_steps.svc.patterns_ = patt_\n elif decoder == 'log_reg':\n clf.named_steps.logisticregression.patterns_ = patt_\n\n # back transform using steps in pipeline\n patterns = get_coef(clf, 'patterns_', inverse_transform=True)\n\n # return subject scores, prediction confidence and topographical patterns\n return scores, preds, patterns\n\n\ndef get_p_scores(scores, chance=.5,\n tfce=False, permutations=1000, threshold=None, n_jobs=1):\n \"\"\"\n Calculate p_values from scores for significance masking using either\n TFCE or FDR.\n\n Parameters\n ----------\n scores: numpy array\n Calculated scores from decoder\n chance: float\n Indicate chance level\n tfce: True | False\n Specify whether to Threshold Free Cluster Enhancement (True)\n or FDR (False)\n permutations: int\n The number of permutations to compute.\n threshold: float | dict | None\n Threshold that needs to be exceeded to achieve significance\n n_jobs: int\n The number of jobs to run in parallel (default 1). Requires the\n joblib package.\n\n \"\"\"\n p_values = (parallel_stats(scores - chance, n_jobs=n_jobs) if tfce is False\n else stats_tfce(scores - chance,\n n_permutations=permutations,\n threshold=threshold,\n n_jobs=n_jobs))\n return p_values\n\n\ndef grouper(iterable):\n \"\"\"\n List of time points of significance, identifies neighbouring time points.\n \"\"\"\n prev = None\n group = []\n for item in iterable:\n if not prev or round(item - prev, 2) <= .01:\n group.append(item)\n else:\n yield group\n group = [item]\n prev = item\n if group:\n yield group\n\n\ndef find_clus(sig_times):\n \"\"\"\n Identify time points of significance from FDR correction, results in\n lists of ranges and individual time points of significance and\n creates a dictionary for later use.\n\n Parameters\n ----------\n sig_times: list\n List of significant time points\n \"\"\"\n group = dict(enumerate(grouper(sig_times)))\n clus = []\n for key in group.keys():\n ls = group[key]\n clus.append((([ls[0], ls[-1]] if round((ls[1] - ls[0]), 2) <= 0.01\n else [ls[1], ls[-1]]) if len(group[key]) > 1\n else group[key]))\n return clus\n\n\ndef get_stats_lines(scores, times, test_times, alphas=[.05, .01]):\n \"\"\"\n Calculate subject level decoder performances for each of the times series\n plots and perform FDR correction (p<0.05 and p<0.01).\n Creates a dictionary of relevant stats.\n\n Parameters\n ----------\n\n scores: array\n times: array\n test_times: dict\n alphas: list\n List of alphas for significance masking default masks for p<0.05\n and p<0.01\n \"\"\"\n\n # get alpha levels\n alpha1, alpha2 = alphas\n\n # get the diagonal (training_t==testing_t) for each subject,\n # FDR correction, and mask time points of significance\n diag = np.asarray([sc.diagonal() for sc in scores])\n diag_pvalues = parallel_stats(list(diag - 0.5))\n diag1, diag2 = times[diag_pvalues < alpha1], times[diag_pvalues < alpha2]\n\n # get component boundaries for perfomance analysis\n min_max = {k: [(np.abs(v[0] - times)).argmin(),\n (np.abs(v[1] - times)).argmin()]\n for (k, v) in test_times.items()}\n\n # average classifier performance over time for time window of interest\n # for each subject\n class_performance = {k: scores[:, v[0]:v[1], :].mean(1)\n for (k, v) in min_max.items()}\n\n # FDR correction and significance testing\n p_vals = {k: parallel_stats(list(v - 0.5))\n for (k, v) in class_performance.items()}\n\n # mask time points of significance that are p<0.05 (alpha1) and\n # p<0.01 (alpha2)\n masks = {k: [times[v < alpha] for alpha in alphas]\n for (k, v) in p_vals.items()}\n\n # # *** keep this just in case we neeed it later ***\n # # average difference between classifier performance over time for\n # time window of interest for each subject\n # diff = np.array([(sc[p6_min:p6_max].mean(0) -\n # sc[n4_min:n4_max].mean(0))\n # for sc in scores])\n # # FDR correction and significance masking\n # diff_pvalues = parallel_stats(list(diff))\n # diff1, diff2 = xx[diff_pvalues < alpha1], xx[diff_pvalues < alpha2]\n\n # create dict of diagonal stats\n diag_stats = {'diag': [diag, diag1, diag2]}\n\n # create dict of classifier stats\n class_stats = {k: [v, m[0], m[1]]\n for ((k, v), (a, m)) in\n zip(class_performance.items(), masks.items())}\n\n # object for return\n stats_dict = {**diag_stats, **class_stats}\n\n return stats_dict\n\n\ndef plot_image(data, times, mask=None, ax=None, vmax=None, vmin=None,\n draw_mask=None, draw_contour=None, colorbar=True,\n draw_diag=True, draw_zerolines=True,\n xlabel=\"Time (s)\", ylabel=\"Time (s)\",\n cbar_unit=\"%\", cmap=\"RdBu_r\",\n mask_alpha=.75, mask_cmap=\"RdBu_r\"):\n \"\"\"Return fig and ax for further styling of GAT matrix, e.g., titles\n\n Parameters\n ----------\n data: array of scores\n times: list of epoched time points\n mask: None | array\n ...\n \"\"\"\n if ax is None:\n fig = plt.figure()\n ax = plt.axes()\n\n if vmax is None:\n vmax = np.abs(data).max()\n if vmin is None:\n vmax = np.abs(data).max()\n vmin = -vmax\n tmin, tmax = xlim = times[0], times[-1]\n extent = [tmin, tmax, tmin, tmax]\n im_args = dict(interpolation='nearest', origin='lower',\n extent=extent, aspect='auto', vmin=vmin, vmax=vmax)\n\n if mask is not None:\n draw_mask = True if draw_mask is None else draw_mask\n draw_contour = True if draw_contour is None else draw_contour\n if any((draw_mask, draw_contour,)):\n if mask is None:\n raise ValueError(\"No mask to show!\")\n\n if draw_mask:\n ax.imshow(data, alpha=mask_alpha, cmap=mask_cmap, **im_args)\n im = ax.imshow(np.ma.masked_where(~mask, data), cmap=cmap, **im_args)\n else:\n im = ax.imshow(data, cmap=cmap, **im_args)\n if draw_contour and np.unique(mask).size == 2:\n big_mask = np.kron(mask, np.ones((10, 10)))\n ax.contour(big_mask, colors=[\"k\"], extent=extent, linewidths=[1],\n aspect=1,\n corner_mask=False, antialiased=False, levels=[.5])\n ax.set_xlim(xlim)\n ax.set_ylim(xlim)\n\n if draw_diag:\n ax.plot((tmin, tmax), (tmin, tmax), color=\"k\", linestyle=\":\")\n if draw_zerolines:\n ax.axhline(0, color=\"k\", linestyle=\":\")\n ax.axvline(0, color=\"k\", linestyle=\":\")\n\n ax.set_ylabel(ylabel)\n ax.set_xlabel(xlabel, labelpad=10.0)\n\n if colorbar:\n cbar = plt.colorbar(im, ax=ax)\n cbar.ax.set_title(cbar_unit)\n ax.set_aspect(1. / ax.get_data_ratio())\n ax.set_title(\"GAT Matrix\", pad=10.0)\n # ax.title.set_position([.5, 1.025])\n\n return fig if ax is None else ax\n\n\ndef get_dfs(stats_dict, df_type=False):\n \"\"\"Create DataFrames for time series plotting\"\"\"\n from config import subjects\n # get times\n times = get_epochs(subjects[0]).times\n\n if not df_type:\n # create dataframe for N400 and P600 decoders\n df = pd.DataFrame()\n sub, time, accuracy, comp = [], [], [], []\n comps = list(stats_dict.keys())\n comps = [i for i in comps if i != 'diag']\n for c in comps:\n for ii, s in enumerate(stats_dict[c][0]):\n for t, a in enumerate(s):\n sub.append(ii)\n accuracy.append(a)\n time.append(times[t])\n comp.append(c)\n df[\"Time (s)\"] = time\n df[\"Subject\"] = sub\n df[\"Accuracy (%)\"] = accuracy\n df[\"Component\"] = comp\n\n else:\n # create dataframe for diagonal or difference between components\n sub, time, ac = [], [], []\n df = pd.DataFrame()\n for ii, s in enumerate(stats_dict[df_type][0]):\n for t, a in enumerate(s):\n sub.append(ii), ac.append(a), time.append(times[t])\n df[\"Time (s)\"], df[\"Subject\"] = time, sub\n df[\"{}\".format((\"Accuracy (%)\" if df_type == \"diag\"\n else \"Difference in Accuracy (%)\"))] = ac\n\n return df\n"
] |
[
[
"numpy.logical_or",
"numpy.quantile",
"numpy.asarray",
"scipy.stats.median_abs_deviation",
"numpy.ones",
"numpy.mean",
"numpy.std",
"numpy.arange",
"numpy.transpose",
"numpy.diag",
"numpy.argwhere",
"numpy.abs",
"numpy.squeeze",
"numpy.nanmedian"
],
[
"matplotlib.pyplot.colorbar",
"sklearn.model_selection.StratifiedKFold",
"pandas.DataFrame",
"sklearn.svm.SVC",
"numpy.prod",
"matplotlib.pyplot.axes",
"sklearn.linear_model.RidgeClassifier",
"numpy.array",
"numpy.reshape",
"matplotlib.pyplot.figure",
"numpy.hstack",
"scipy.stats.wilcoxon",
"numpy.ma.masked_where",
"numpy.isnan",
"numpy.cov",
"sklearn.preprocessing.StandardScaler",
"numpy.ones",
"sklearn.linear_model.LogisticRegression",
"numpy.abs",
"numpy.unique"
]
] |
dnnspark/bulletwrapper
|
[
"3d034ee27ccf1613e84bd0beaae345eb4cbb9f91"
] |
[
"bulletwrapper/hooks/box_packing/pack_box.py"
] |
[
"import numpy as np\nfrom bulletwrapper.util.object_loader import OBJFile\n\nclass Block():\n '''\n This class represent a 2D rectangle associated with a top-down view of a cuboid.\n Each cuboid gives rise to 6 sides * 4 orientation = 24 axis-aligned blocks.\n The rectangle is represented by its width and height; this data is used to \n compute the layout of blocks.\n The block also has fields of rotation matrix and z-offset, which are used to\n convert the 2D position of block to a full 3D pose of cuboid.\n '''\n\n def __init__(self, width, height, R, zoffset):\n self.dim = (width, height)\n self.R = R\n self.zoffset = zoffset\n\n\ndef cuboid_to_blocks(vertices, inplane_rot_angles=[0]):\n '''\n CRUCIAL assumption:\n vertices collectively represent an axis-aligned 3D cuboid centered at origin.\n\n Input\n =====\n vertices: np.ndarray\n (N,3) float tensor, each row is a vertex.\n\n Return\n ======\n blocks: [Block]\n A list of N*24 blocks, where N = len(inplane_rot_angles)\n\n # blocks: np.ndarray\n # (N*24,2) float tensor, where N = len(inplane_rot_angles)\n\n # rot_mat: np.ndarray\n # (N*24,3,3) float tensor that contains N 3x3 rotation matrices \n # associated with blocks.\n '''\n\n axes = np.array([\n [ 1, 0, 0],\n [-1, 0, 0],\n [ 0, 1, 0],\n [ 0,-1, 0],\n [ 0, 0, 1],\n [ 0, 0,-1],\n ])\n\n # Rs, blocks, zoffsets = [], [], []\n blocks = []\n for xaxis in axes:\n for yaxis in axes:\n if np.dot(xaxis, yaxis) != 0:\n continue\n zaxis = np.cross(xaxis, yaxis)\n\n R0 = np.array([xaxis, yaxis, zaxis]).T # object-to-world rotation\n\n for theta in inplane_rot_angles:\n _theta = np.pi * theta/180.\n c,s = np.cos(_theta), np.sin(_theta)\n R_inplane = np.array([\n [c, -s, 0],\n [s, c, 0],\n [0, 0, 1],\n ])\n R = np.dot(R_inplane, R0)\n # R = np.dot(R0, R_inplane)\n\n transformed = np.dot( R, vertices.T ).T\n x1y1z1 = np.min(transformed, axis=0)\n x2y2z2 = np.max(transformed, axis=0)\n # assert np.allclose(x1y1z1 + x2y2z2 , 0) # for perfect cuboid\n\n diagonal = x2y2z2 - x1y1z1\n W,H = diagonal[:2]\n\n zoffset = -x1y1z1[-1]\n\n blocks.append( Block(W, H, R, zoffset) )\n\n return blocks\n\ndef pack_bin(blocks, box, slack=0.):\n '''\n 2D bin-packing divide-and-conquer algorithm.\n\n Input\n =====\n blocks: [Blocks]\n (N,2) float tensor representing dimensions of 2D blocks. \n The first column are widths, the second heights.\n\n box: [float, float]\n width, height\n\n slack: (float, float)\n range of slack\n\n Return\n ======\n block_layout: [ (int, (float, float)) ]\n a list of (index, (start_x, start_y))\n\n '''\n\n blocks_dim = np.array([block.dim for block in blocks])\n blocks_dim_w_slack = blocks_dim + slack\n\n # randomly choose a block that fits.\n fit = blocks_dim_w_slack <= np.expand_dims(box, 0)\n fit = np.where(np.logical_and(fit[:,0], fit[:,1]))[0]\n\n if len(fit) == 0:\n # no blocks fit.\n return []\n\n pick = np.random.choice(fit)\n block_dim_w_slack = blocks_dim_w_slack[pick]\n\n W,H = box\n w,h = block_dim_w_slack\n\n # randomly choose one of the two ways to split the remaining area into two rectangular areas.\n split = np.random.choice(2)\n if split == 0:\n # split horizontally.\n two_residual_boxes = [\n [W-w, h],\n [W, H-h], \n ]\n\n else:\n # split vertically.\n two_residual_boxes = [\n [W-w, H],\n [w, H-h],\n ]\n\n # randomly choose one of the four corners to place the block.\n corner = np.random.choice(4)\n if corner == 0:\n # upper-left corner\n layout = [ (pick, (0., 0.)) ]\n\n two_offsets = [\n [w, 0.],\n [0., h]\n ]\n\n elif corner == 1:\n # upper-right corner\n layout = [ (pick, (W-w, 0.)) ]\n\n if split == 0:\n two_offsets = [\n [0., 0.],\n [0., h],\n ]\n else:\n two_offsets = [\n [0., 0.],\n [W-w, h],\n ]\n elif corner == 2:\n # lower-left corner\n layout = [ (pick, (0., H-h)) ]\n\n if split == 0:\n two_offsets = [\n [w, H-h],\n [0., 0.],\n ]\n else:\n two_offsets = [\n [w, 0.],\n [0., 0.],\n ]\n\n else: #corner == 3:\n # lower-right corner\n layout = [ (pick, (W-w, H-h)) ]\n\n if split == 0:\n two_offsets = [\n [0., H-h],\n [0., 0.],\n ]\n else:\n two_offsets = [\n [0., 0.],\n [W-w, 0.],\n ]\n\n for residual_box, offsets in zip(two_residual_boxes, two_offsets):\n sub_layout = pack_bin(blocks, residual_box, slack)\n sub_layout = [(idx, (start_x+offsets[0], start_y+offsets[1])) for idx, (start_x, start_y) in sub_layout]\n layout += sub_layout\n\n return layout\n\ndef compute_poses(blocks, block_layout, box_dim, box_center):\n\n # positions = []\n poses = []\n box_dim, box_center = np.array(box_dim), np.array(box_center)\n for idx, (x1, y1) in block_layout:\n block = blocks[idx]\n\n R = block.R\n xy_offset = np.array([x1,y1]) + .5 * np.array(block.dim) - .5 * box_dim + box_center\n z_offset = block.zoffset\n\n position = list(xy_offset) + [z_offset]\n poses.append( (R, position))\n\n return poses\n\ndef make_packed_cuboids_scene(path_to_obj, mesh_scale, box_dim, box_center, inplane_rot_angles, slack, block_filter=None):\n vertices = np.array( OBJFile(path_to_obj, None).vertices ) * mesh_scale\n blocks = cuboid_to_blocks(vertices, inplane_rot_angles=inplane_rot_angles)\n if block_filter is not None:\n blocks = [block for block in blocks if block_filter(block)]\n block_layout = pack_bin(blocks, box_dim, slack=slack)\n\n poses = compute_poses(blocks, block_layout, box_dim, box_center)\n\n return poses\n"
] |
[
[
"numpy.max",
"numpy.array",
"numpy.dot",
"numpy.random.choice",
"numpy.sin",
"numpy.min",
"numpy.logical_and",
"numpy.cos",
"numpy.cross",
"numpy.expand_dims"
]
] |
ShegnkaiWu/IoU-aware-single-stage-object-detector-for-accurate-localization
|
[
"67b8955eb59137590dbadc6aac45529ae9459e4a"
] |
[
"mmdet/models/bbox_heads/convfc_bbox_head.py"
] |
[
"import torch.nn as nn\n\nfrom .bbox_head import BBoxHead\nfrom ..registry import HEADS\nfrom ..utils import ConvModule\n\n\n@HEADS.register_module\nclass ConvFCBBoxHead(BBoxHead):\n \"\"\"More general bbox head, with shared conv and fc layers and two optional\n separated branches.\n\n /-> cls convs -> cls fcs -> cls\n shared convs -> shared fcs\n \\-> reg convs -> reg fcs -> reg\n \"\"\" # noqa: W605\n\n def __init__(self,\n num_shared_convs=0,\n num_shared_fcs=0,\n num_cls_convs=0,\n num_cls_fcs=0,\n num_reg_convs=0,\n num_reg_fcs=0,\n conv_out_channels=256,\n fc_out_channels=1024,\n conv_cfg=None,\n norm_cfg=None,\n with_avg_pool_shared=False,\n with_avg_pool_cls=False,\n with_avg_pool_reg=False,\n *args,\n **kwargs):\n super(ConvFCBBoxHead, self).__init__(*args, **kwargs)\n assert (num_shared_convs + num_shared_fcs + num_cls_convs +\n num_cls_fcs + num_reg_convs + num_reg_fcs > 0)\n if num_cls_convs > 0 or num_reg_convs > 0:\n assert num_shared_fcs == 0\n if not self.with_cls:\n assert num_cls_convs == 0 and num_cls_fcs == 0\n if not self.with_reg:\n assert num_reg_convs == 0 and num_reg_fcs == 0\n self.num_shared_convs = num_shared_convs\n self.num_shared_fcs = num_shared_fcs\n self.num_cls_convs = num_cls_convs\n self.num_cls_fcs = num_cls_fcs\n self.num_reg_convs = num_reg_convs\n self.num_reg_fcs = num_reg_fcs\n self.conv_out_channels = conv_out_channels\n self.fc_out_channels = fc_out_channels\n self.conv_cfg = conv_cfg\n self.norm_cfg = norm_cfg\n\n # added by WSK\n self.with_avg_pool_shared = with_avg_pool_shared\n self.with_avg_pool_cls = with_avg_pool_cls\n self.with_avg_pool_reg = with_avg_pool_reg\n\n # add shared convs and fcs\n self.shared_convs, self.shared_fcs, last_layer_dim = \\\n self._add_conv_fc_branch(\n self.num_shared_convs, self.num_shared_fcs, self.in_channels,\n True)\n self.shared_out_channels = last_layer_dim\n\n # add cls specific branch\n self.cls_convs, self.cls_fcs, self.cls_last_dim = \\\n self._add_conv_fc_branch(\n self.num_cls_convs, self.num_cls_fcs, self.shared_out_channels)\n\n # add reg specific branch\n self.reg_convs, self.reg_fcs, self.reg_last_dim = \\\n self._add_conv_fc_branch(\n self.num_reg_convs, self.num_reg_fcs, self.shared_out_channels)\n\n if self.num_shared_fcs == 0 and not self.with_avg_pool:\n if self.num_cls_fcs == 0:\n self.cls_last_dim *= (self.roi_feat_size * self.roi_feat_size)\n if self.num_shared_fcs == 0 and not self.with_avg_pool_reg:\n if self.num_reg_fcs == 0:\n self.reg_last_dim *= (self.roi_feat_size * self.roi_feat_size)\n\n self.relu = nn.ReLU(inplace=True)\n # reconstruct fc_cls and fc_reg since input channels are changed\n if self.with_cls:\n self.fc_cls = nn.Linear(self.cls_last_dim, self.num_classes)\n if self.with_reg:\n out_dim_reg = 4 if self.reg_class_agnostic else 4 * self.num_classes\n self.fc_reg = nn.Linear(self.reg_last_dim, out_dim_reg)\n\n def _add_conv_fc_branch(self,\n num_branch_convs,\n num_branch_fcs,\n in_channels,\n is_shared=False):\n \"\"\"Add shared or separable branch\n\n convs -> avg pool (optional) -> fcs\n \"\"\"\n last_layer_dim = in_channels\n # add branch specific conv layers\n branch_convs = nn.ModuleList()\n if num_branch_convs > 0:\n for i in range(num_branch_convs):\n conv_in_channels = (\n last_layer_dim if i == 0 else self.conv_out_channels)\n branch_convs.append(\n ConvModule(\n conv_in_channels,\n self.conv_out_channels,\n 3,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n last_layer_dim = self.conv_out_channels\n # add branch specific fc layers\n branch_fcs = nn.ModuleList()\n if num_branch_fcs > 0:\n # for shared branch, only consider self.with_avg_pool\n # for separated branches, also consider self.num_shared_fcs\n if (is_shared\n or self.num_shared_fcs == 0) and not self.with_avg_pool:\n last_layer_dim *= (self.roi_feat_size * self.roi_feat_size)\n for i in range(num_branch_fcs):\n fc_in_channels = (\n last_layer_dim if i == 0 else self.fc_out_channels)\n branch_fcs.append(\n nn.Linear(fc_in_channels, self.fc_out_channels))\n last_layer_dim = self.fc_out_channels\n return branch_convs, branch_fcs, last_layer_dim\n\n def init_weights(self):\n super(ConvFCBBoxHead, self).init_weights()\n for module_list in [self.shared_fcs, self.cls_fcs, self.reg_fcs]:\n for m in module_list.modules():\n if isinstance(m, nn.Linear):\n nn.init.xavier_uniform_(m.weight)\n nn.init.constant_(m.bias, 0)\n\n def forward(self, x):\n # shared part\n if self.num_shared_convs > 0:\n for conv in self.shared_convs:\n x = conv(x)\n\n if self.num_shared_fcs > 0:\n if self.with_avg_pool:\n x = self.avg_pool(x)\n x = x.view(x.size(0), -1)\n for fc in self.shared_fcs:\n x = self.relu(fc(x))\n # separate branches\n x_cls = x\n x_reg = x\n\n for conv in self.cls_convs:\n x_cls = conv(x_cls)\n if x_cls.dim() > 2:\n if self.with_avg_pool:\n x_cls = self.avg_pool(x_cls)\n x_cls = x_cls.view(x_cls.size(0), -1)\n for fc in self.cls_fcs:\n x_cls = self.relu(fc(x_cls))\n\n for conv in self.reg_convs:\n x_reg = conv(x_reg)\n if x_reg.dim() > 2:\n if self.with_avg_pool_reg:\n x_reg = self.avg_pool(x_reg)\n x_reg = x_reg.view(x_reg.size(0), -1)\n for fc in self.reg_fcs:\n x_reg = self.relu(fc(x_reg))\n\n cls_score = self.fc_cls(x_cls) if self.with_cls else None\n bbox_pred = self.fc_reg(x_reg) if self.with_reg else None\n return cls_score, bbox_pred\n\n\n@HEADS.register_module\nclass SharedFCBBoxHead(ConvFCBBoxHead):\n\n def __init__(self, num_fcs=2, fc_out_channels=1024, *args, **kwargs):\n assert num_fcs >= 1\n super(SharedFCBBoxHead, self).__init__(\n num_shared_convs=0,\n num_shared_fcs=num_fcs,\n num_cls_convs=0,\n num_cls_fcs=0,\n num_reg_convs=0,\n num_reg_fcs=0,\n fc_out_channels=fc_out_channels,\n *args,\n **kwargs)\n\n@HEADS.register_module\nclass SeperableBranchBBoxHead(ConvFCBBoxHead):\n def __init__(self, num_cls_fc=2 , num_reg_convs=2, conv_out_channels=256, fc_out_channels=1024, with_avg_pool_reg=True, *args, **kwargs):\n assert num_cls_fc >= 1 and num_reg_convs >=1\n super(SeperableBranchBBoxHead, self).__init__(\n num_shared_convs=0,\n num_shared_fcs=0,\n num_cls_convs=0,\n num_cls_fcs=num_cls_fc,\n num_reg_convs=num_reg_convs,\n num_reg_fcs=0,\n conv_out_channels=conv_out_channels,\n fc_out_channels=fc_out_channels,\n with_avg_pool_reg=with_avg_pool_reg\n *args,\n **kwargs)\n"
] |
[
[
"torch.nn.Linear",
"torch.nn.ModuleList",
"torch.nn.init.constant_",
"torch.nn.init.xavier_uniform_",
"torch.nn.ReLU"
]
] |
chrfla/sec-filings-nlp
|
[
"dd296b4e7734e8bc682ba115b6f5f68a4e55c992"
] |
[
"09_LDA_all_years.py"
] |
[
"#!/usr/bin/env python\n# coding: utf-8\n\n####### Import packages #########\n\nfrom pprint import pprint\nimport pickle\nfrom wordcloud import WordCloud\nimport matplotlib.pyplot as plt\nimport gensim\nimport gensim.corpora as corpora\nfrom gensim.utils import simple_preprocess\nfrom gensim.models import LdaMulticore\nimport spacy\nimport pyLDAvis\nimport pyLDAvis.gensim\nimport logging\nlogging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.ERROR)\nimport random\nimport warnings\nwarnings.filterwarnings(\"ignore\",category=DeprecationWarning)\nimport nltk;\nnltk.download('stopwords')\nfrom nltk.corpus import stopwords\nstop_words = stopwords.words('english')\nstop_words.extend(['may', 'could', 'business', 'result', 'affect', 'include'])\nnlp = spacy.load('en', disable=['parser', 'ner'])\nfrom _settings import main_dir, lda_data_dir\n\n\n\n\n####### Define functions #########\n\n\ndef sent_to_words(sentences):\n for sentence in sentences:\n yield(gensim.utils.simple_preprocess(str(sentence), deacc=True)) # deacc=True removes punctuations\n\n# Define functions for stopwords, bigrams, trigrams and lemmatization\ndef remove_stopwords(texts):\n return [[word for word in simple_preprocess(str(doc)) if word not in stop_words] for doc in texts]\n\ndef lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):\n texts_out = []\n for sent in texts:\n doc = nlp(\" \".join(sent)) \n texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])\n return texts_out\n\n\ndef Convert(tup, di): \n for a, b in tup:\n di[a] = float(b)\n return di \n\n\n\ndef train_LDA_model (data, num_topics, CPUs):\n\n # Pre-processing\n sentences = [nltk.tokenize.sent_tokenize(doc) for doc in data]\n sentences = [val for sublist in sentences for val in sublist]\n data_words = list(sent_to_words(sentences))\n\n # Remove Stop Words\n data_words_nostops = remove_stopwords(data_words)\n \n # Initialize spacy 'en' model, keeping only tagger component (for efficiency)\n # python3 -m spacy download en\n nlp = spacy.load('en', disable=['parser', 'ner'])\n \n # Do lemmatization keeping only noun, adj, vb, adv\n data_lemmatized = lemmatization(data_words_nostops, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV'])\n \n # Create Dictionary\n id2word = corpora.Dictionary(data_lemmatized)\n \n # Create Corpus\n texts = data_lemmatized\n \n # Term Document Frequency\n corpus = [id2word.doc2bow(text) for text in texts]\n\n\n # ## Train LDA Model\n \n # Build LDA model\n lda_model = LdaMulticore(corpus=corpus,\n id2word=id2word,\n num_topics = num_topics, \n random_state=50,\n chunksize=100,\n passes=10,\n per_word_topics=True,\n workers = CPUs)\n \n model_dest = lda_data_dir + 'LDA_model/all_years_2007_2017/lda_model_all_years.model'\n lda_model.save(model_dest)\n\n \n # Print the Keyword in the 10 topics\n pprint(lda_model.print_topics())\n doc_lda = lda_model[corpus]\n\n # Visualize the topics\n vis = pyLDAvis.gensim.prepare(lda_model, corpus, id2word)\n storage_dest_lda_html = lda_data_dir + 'LDA_model/all_years_2007_2017/all_years_2007_2017_local_lda.html'\n pyLDAvis.save_html(vis, storage_dest_lda_html)\n\n \n wordcloud_dest = lda_data_dir + 'LDA_model/all_years_2007_2017/wordclouds/'\n \n for t in range(lda_model.num_topics):\n plt.figure()\n dictionary = {} \n plt.imshow(WordCloud().fit_words(Convert(lda_model.show_topic(t, 30), dictionary)))\n plt.axis(\"off\")\n plt.title(\"Topic_\" + str(t))\n plt.show()\n plt.savefig(wordcloud_dest + \"Topic #\" + str(t)+'.png') # set location on server\n\n\n return lda_model\n\n\n\n####### Execute code below #########\n\ndata = pickle.load(open(main_dir + 'data/clean_text.list', \"rb\" ))\nlda_model = train_LDA_model (data, num_topics = 30, CPUs = 6)\n"
] |
[
[
"matplotlib.pyplot.show",
"matplotlib.pyplot.axis",
"matplotlib.pyplot.figure"
]
] |
minhnhatphan/CenterTrack
|
[
"f459601c8843018ba791fa78931ad291e108092a"
] |
[
"src/tools/convert_mot_det_to_results.py"
] |
[
"import json\nimport numpy as np\nimport os\nfrom collections import defaultdict\nsplit = 'train'\n\nDET_PATH = '../../data/mot17/train'\nANN_PATH = '../../data/mot17/annotations/{}.json'.format(split)\nOUT_DIR = '../../data/mot17/results/'\nOUT_PATH = OUT_DIR + '{}_det.json'.format(split)\n\nif __name__ == '__main__':\n if not os.path.exists(OUT_DIR):\n os.mkdir(OUT_DIR)\n seqs = [s for s in os.listdir(DET_PATH)]\n data = json.load(open(ANN_PATH, 'r'))\n images = data['images']\n image_to_anns = defaultdict(list)\n for seq in sorted(seqs):\n print('seq', seq)\n seq_path = '{}/{}/'.format(DET_PATH, seq)\n if split == 'val_half':\n ann_path = seq_path + 'det/det_val_half.txt'\n train_ann_path = seq_path + 'det/det_train_half.txt'\n train_anns = np.loadtxt(train_ann_path, dtype=np.float32, delimiter=',')\n frame_base = int(train_anns[:, 0].max())\n else:\n ann_path = seq_path + 'det/det.txt'\n frame_base = 0\n # if not IS_THIRD_PARTY:\n anns = np.loadtxt(ann_path, dtype=np.float32, delimiter=',')\n for i in range(len(anns)):\n frame_id = int(anns[i][0])\n file_name = '{}/img1/{:06d}.jpg'.format(seq, frame_id + frame_base)\n bbox = (anns[i][2:6]).tolist()\n score = 1 # float(anns[i][8])\n image_to_anns[file_name].append(bbox + [score])\n\n results = {}\n for image_info in images:\n image_id = image_info['id']\n file_name = image_info['file_name']\n dets = image_to_anns[file_name]\n results[image_id] = []\n for det in dets:\n bbox = [float(det[0]), float(det[1]), \\\n float(det[0] + det[2]), float(det[1] + det[3])]\n ct = [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2]\n results[image_id].append(\n {'bbox': bbox, 'score': float(det[4]), 'class': 1, 'ct': ct})\n out_path = OUT_PATH\n json.dump(results, open(out_path, 'w'))\n"
] |
[
[
"numpy.loadtxt"
]
] |
FeiYuejiao/NLP_Pretrain
|
[
"7aa4693c31a7bba9b90f401d2586ef154dd7fb81"
] |
[
"model/densenet.py"
] |
[
"'''DenseNet in PyTorch.'''\nimport math\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n\nclass Bottleneck(nn.Module):\n def __init__(self, in_planes, growth_rate):\n super(Bottleneck, self).__init__()\n self.bn1 = nn.BatchNorm2d(in_planes)\n self.conv1 = nn.Conv2d(in_planes, 4*growth_rate, kernel_size=1, bias=False)\n self.bn2 = nn.BatchNorm2d(4*growth_rate)\n self.conv2 = nn.Conv2d(4*growth_rate, growth_rate, kernel_size=3, padding=1, bias=False)\n\n def forward(self, x):\n out = self.conv1(F.relu(self.bn1(x)))\n out = self.conv2(F.relu(self.bn2(out)))\n out = torch.cat([out,x], 1)\n return out\n\n\nclass Transition(nn.Module):\n def __init__(self, in_planes, out_planes):\n super(Transition, self).__init__()\n self.bn = nn.BatchNorm2d(in_planes)\n self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=1, bias=False)\n\n def forward(self, x):\n out = self.conv(F.relu(self.bn(x)))\n out = F.avg_pool2d(out, 2)\n return out\n\n\nclass DenseNet(nn.Module):\n def __init__(self, block, nblocks, growth_rate=12, reduction=0.5, num_classes=10):\n super(DenseNet, self).__init__()\n self.growth_rate = growth_rate\n\n num_planes = 2*growth_rate\n self.conv1 = nn.Conv2d(3, num_planes, kernel_size=3, padding=1, bias=False)\n\n self.dense1 = self._make_dense_layers(block, num_planes, nblocks[0])\n num_planes += nblocks[0]*growth_rate\n out_planes = int(math.floor(num_planes*reduction))\n self.trans1 = Transition(num_planes, out_planes)\n num_planes = out_planes\n\n self.dense2 = self._make_dense_layers(block, num_planes, nblocks[1])\n num_planes += nblocks[1]*growth_rate\n out_planes = int(math.floor(num_planes*reduction))\n self.trans2 = Transition(num_planes, out_planes)\n num_planes = out_planes\n\n self.dense3 = self._make_dense_layers(block, num_planes, nblocks[2])\n num_planes += nblocks[2]*growth_rate\n out_planes = int(math.floor(num_planes*reduction))\n self.trans3 = Transition(num_planes, out_planes)\n num_planes = out_planes\n\n self.dense4 = self._make_dense_layers(block, num_planes, nblocks[3])\n num_planes += nblocks[3]*growth_rate\n\n self.bn = nn.BatchNorm2d(num_planes)\n self.linear = nn.Linear(num_planes, num_classes)\n\n def _make_dense_layers(self, block, in_planes, nblock):\n layers = []\n for i in range(nblock):\n layers.append(block(in_planes, self.growth_rate))\n in_planes += self.growth_rate\n return nn.Sequential(*layers)\n\n def forward(self, x):\n out = self.conv1(x)\n out = self.trans1(self.dense1(out))\n out = self.trans2(self.dense2(out))\n out = self.trans3(self.dense3(out))\n out = self.dense4(out)\n out = F.relu(self.bn(out))\n #out = F.avg_pool2d(F.relu(self.bn(out)), 4)\n #out = out.view(out.size(0), -1)\n #out = self.linear(out)\n return out\n\ndef DenseNet121():\n return DenseNet(Bottleneck, [6,12,24,16], growth_rate=32)\n\ndef DenseNet169():\n return DenseNet(Bottleneck, [6,12,32,32], growth_rate=32)\n\ndef DenseNet201():\n return DenseNet(Bottleneck, [6,12,48,32], growth_rate=32)\n\ndef DenseNet161():\n return DenseNet(Bottleneck, [6,12,36,24], growth_rate=48)\n\ndef densenet_cifar():\n return DenseNet(Bottleneck, [6,12,24,16], growth_rate=12)\n\ndef test():\n net = densenet_cifar()\n x = torch.randn(1,3,32,32)\n y = net(x)\n print(y)\n\n# test()\n"
] |
[
[
"torch.nn.Linear",
"torch.cat",
"torch.nn.functional.avg_pool2d",
"torch.nn.Sequential",
"torch.nn.BatchNorm2d",
"torch.nn.Conv2d",
"torch.randn"
]
] |
SoftwareDev/mat-plot-lib
|
[
"abaf94859d5ef6e653a4d8a7ce2c59cea1724a57",
"255a79b106c98c1904489afe6a754e4d943179d6",
"a429c415bdb6e54ccfe004a48fdc034ea8e9d329",
"a429c415bdb6e54ccfe004a48fdc034ea8e9d329",
"255a79b106c98c1904489afe6a754e4d943179d6"
] |
[
"lib/matplotlib/colors.py",
"examples/units/bar_unit_demo.py",
"lib/matplotlib/patches.py",
"lib/matplotlib/bezier.py",
"examples/api/demo_affine_image.py"
] |
[
"\"\"\"\nA module for converting numbers or color arguments to *RGB* or *RGBA*\n\n*RGB* and *RGBA* are sequences of, respectively, 3 or 4 floats in the\nrange 0-1.\n\nThis module includes functions and classes for color specification\nconversions, and for mapping numbers to colors in a 1-D array of colors called\na colormap. Colormapping typically involves two steps: a data array is first\nmapped onto the range 0-1 using an instance of :class:`Normalize` or of a\nsubclass; then this number in the 0-1 range is mapped to a color using an\ninstance of a subclass of :class:`Colormap`. Two are provided here:\n:class:`LinearSegmentedColormap`, which is used to generate all the built-in\ncolormap instances, but is also useful for making custom colormaps, and\n:class:`ListedColormap`, which is used for generating a custom colormap from a\nlist of color specifications.\n\nThe module also provides a single instance, *colorConverter*, of the\n:class:`ColorConverter` class providing methods for converting single color\nspecifications or sequences of them to *RGB* or *RGBA*.\n\nCommands which take color arguments can use several formats to specify\nthe colors. For the basic built-in colors, you can use a single letter\n\n - b: blue\n - g: green\n - r: red\n - c: cyan\n - m: magenta\n - y: yellow\n - k: black\n - w: white\n\nGray shades can be given as a string encoding a float in the 0-1 range, e.g.::\n\n color = '0.75'\n\nFor a greater range of colors, you have two options. You can specify the\ncolor using an html hex string, as in::\n\n color = '#eeefff'\n\nor you can pass an *R* , *G* , *B* tuple, where each of *R* , *G* , *B* are in\nthe range [0,1].\n\nFinally, legal html names for colors, like 'red', 'burlywood' and 'chartreuse'\nare supported.\n\"\"\"\nfrom __future__ import (absolute_import, division, print_function,\n unicode_literals)\n\nimport six\nfrom six.moves import map, zip\n\nimport re\nimport numpy as np\nfrom numpy import ma\nimport matplotlib.cbook as cbook\n\nparts = np.__version__.split('.')\nNP_MAJOR, NP_MINOR = list(map(int, parts[:2]))\n# true if clip supports the out kwarg\nNP_CLIP_OUT = NP_MAJOR >= 1 and NP_MINOR >= 2\n\ncnames = {\n 'aliceblue': '#F0F8FF',\n 'antiquewhite': '#FAEBD7',\n 'aqua': '#00FFFF',\n 'aquamarine': '#7FFFD4',\n 'azure': '#F0FFFF',\n 'beige': '#F5F5DC',\n 'bisque': '#FFE4C4',\n 'black': '#000000',\n 'blanchedalmond': '#FFEBCD',\n 'blue': '#0000FF',\n 'blueviolet': '#8A2BE2',\n 'brown': '#A52A2A',\n 'burlywood': '#DEB887',\n 'cadetblue': '#5F9EA0',\n 'chartreuse': '#7FFF00',\n 'chocolate': '#D2691E',\n 'coral': '#FF7F50',\n 'cornflowerblue': '#6495ED',\n 'cornsilk': '#FFF8DC',\n 'crimson': '#DC143C',\n 'cyan': '#00FFFF',\n 'darkblue': '#00008B',\n 'darkcyan': '#008B8B',\n 'darkgoldenrod': '#B8860B',\n 'darkgray': '#A9A9A9',\n 'darkgreen': '#006400',\n 'darkkhaki': '#BDB76B',\n 'darkmagenta': '#8B008B',\n 'darkolivegreen': '#556B2F',\n 'darkorange': '#FF8C00',\n 'darkorchid': '#9932CC',\n 'darkred': '#8B0000',\n 'darksage': '#598556',\n 'darksalmon': '#E9967A',\n 'darkseagreen': '#8FBC8F',\n 'darkslateblue': '#483D8B',\n 'darkslategray': '#2F4F4F',\n 'darkturquoise': '#00CED1',\n 'darkviolet': '#9400D3',\n 'deeppink': '#FF1493',\n 'deepskyblue': '#00BFFF',\n 'dimgray': '#696969',\n 'dodgerblue': '#1E90FF',\n 'firebrick': '#B22222',\n 'floralwhite': '#FFFAF0',\n 'forestgreen': '#228B22',\n 'fuchsia': '#FF00FF',\n 'gainsboro': '#DCDCDC',\n 'ghostwhite': '#F8F8FF',\n 'gold': '#FFD700',\n 'goldenrod': '#DAA520',\n 'gray': '#808080',\n 'green': '#008000',\n 'greenyellow': '#ADFF2F',\n 'honeydew': '#F0FFF0',\n 'hotpink': '#FF69B4',\n 'indianred': '#CD5C5C',\n 'indigo': '#4B0082',\n 'ivory': '#FFFFF0',\n 'khaki': '#F0E68C',\n 'lavender': '#E6E6FA',\n 'lavenderblush': '#FFF0F5',\n 'lawngreen': '#7CFC00',\n 'lemonchiffon': '#FFFACD',\n 'lightblue': '#ADD8E6',\n 'lightcoral': '#F08080',\n 'lightcyan': '#E0FFFF',\n 'lightgoldenrodyellow': '#FAFAD2',\n 'lightgreen': '#90EE90',\n 'lightgray': '#D3D3D3',\n 'lightpink': '#FFB6C1',\n 'lightsage': '#BCECAC',\n 'lightsalmon': '#FFA07A',\n 'lightseagreen': '#20B2AA',\n 'lightskyblue': '#87CEFA',\n 'lightslategray': '#778899',\n 'lightsteelblue': '#B0C4DE',\n 'lightyellow': '#FFFFE0',\n 'lime': '#00FF00',\n 'limegreen': '#32CD32',\n 'linen': '#FAF0E6',\n 'magenta': '#FF00FF',\n 'maroon': '#800000',\n 'mediumaquamarine': '#66CDAA',\n 'mediumblue': '#0000CD',\n 'mediumorchid': '#BA55D3',\n 'mediumpurple': '#9370DB',\n 'mediumseagreen': '#3CB371',\n 'mediumslateblue': '#7B68EE',\n 'mediumspringgreen': '#00FA9A',\n 'mediumturquoise': '#48D1CC',\n 'mediumvioletred': '#C71585',\n 'midnightblue': '#191970',\n 'mintcream': '#F5FFFA',\n 'mistyrose': '#FFE4E1',\n 'moccasin': '#FFE4B5',\n 'navajowhite': '#FFDEAD',\n 'navy': '#000080',\n 'oldlace': '#FDF5E6',\n 'olive': '#808000',\n 'olivedrab': '#6B8E23',\n 'orange': '#FFA500',\n 'orangered': '#FF4500',\n 'orchid': '#DA70D6',\n 'palegoldenrod': '#EEE8AA',\n 'palegreen': '#98FB98',\n 'paleturquoise': '#AFEEEE',\n 'palevioletred': '#DB7093',\n 'papayawhip': '#FFEFD5',\n 'peachpuff': '#FFDAB9',\n 'peru': '#CD853F',\n 'pink': '#FFC0CB',\n 'plum': '#DDA0DD',\n 'powderblue': '#B0E0E6',\n 'purple': '#800080',\n 'red': '#FF0000',\n 'rosybrown': '#BC8F8F',\n 'royalblue': '#4169E1',\n 'saddlebrown': '#8B4513',\n 'salmon': '#FA8072',\n 'sage': '#87AE73',\n 'sandybrown': '#FAA460',\n 'seagreen': '#2E8B57',\n 'seashell': '#FFF5EE',\n 'sienna': '#A0522D',\n 'silver': '#C0C0C0',\n 'skyblue': '#87CEEB',\n 'slateblue': '#6A5ACD',\n 'slategray': '#708090',\n 'snow': '#FFFAFA',\n 'springgreen': '#00FF7F',\n 'steelblue': '#4682B4',\n 'tan': '#D2B48C',\n 'teal': '#008080',\n 'thistle': '#D8BFD8',\n 'tomato': '#FF6347',\n 'turquoise': '#40E0D0',\n 'violet': '#EE82EE',\n 'wheat': '#F5DEB3',\n 'white': '#FFFFFF',\n 'whitesmoke': '#F5F5F5',\n 'yellow': '#FFFF00',\n 'yellowgreen': '#9ACD32'}\n\n\n# add british equivs\nfor k, v in list(six.iteritems(cnames)):\n if k.find('gray') >= 0:\n k = k.replace('gray', 'grey')\n cnames[k] = v\n\n\ndef is_color_like(c):\n 'Return *True* if *c* can be converted to *RGB*'\n try:\n colorConverter.to_rgb(c)\n return True\n except ValueError:\n return False\n\n\ndef rgb2hex(rgb):\n 'Given an rgb or rgba sequence of 0-1 floats, return the hex string'\n return '#%02x%02x%02x' % tuple([np.round(val * 255) for val in rgb[:3]])\n\nhexColorPattern = re.compile(\"\\A#[a-fA-F0-9]{6}\\Z\")\n\n\ndef hex2color(s):\n \"\"\"\n Take a hex string *s* and return the corresponding rgb 3-tuple\n Example: #efefef -> (0.93725, 0.93725, 0.93725)\n \"\"\"\n if not isinstance(s, six.string_types):\n raise TypeError('hex2color requires a string argument')\n if hexColorPattern.match(s) is None:\n raise ValueError('invalid hex color string \"%s\"' % s)\n return tuple([int(n, 16) / 255.0 for n in (s[1:3], s[3:5], s[5:7])])\n\n\nclass ColorConverter(object):\n \"\"\"\n Provides methods for converting color specifications to *RGB* or *RGBA*\n\n Caching is used for more efficient conversion upon repeated calls\n with the same argument.\n\n Ordinarily only the single instance instantiated in this module,\n *colorConverter*, is needed.\n \"\"\"\n colors = {\n 'b': (0.0, 0.0, 1.0),\n 'g': (0.0, 0.5, 0.0),\n 'r': (1.0, 0.0, 0.0),\n 'c': (0.0, 0.75, 0.75),\n 'm': (0.75, 0, 0.75),\n 'y': (0.75, 0.75, 0),\n 'k': (0.0, 0.0, 0.0),\n 'w': (1.0, 1.0, 1.0), }\n\n cache = {}\n\n def to_rgb(self, arg):\n \"\"\"\n Returns an *RGB* tuple of three floats from 0-1.\n\n *arg* can be an *RGB* or *RGBA* sequence or a string in any of\n several forms:\n\n 1) a letter from the set 'rgbcmykw'\n 2) a hex color string, like '#00FFFF'\n 3) a standard name, like 'aqua'\n 4) a string representation of a float, like '0.4',\n indicating gray on a 0-1 scale\n\n if *arg* is *RGBA*, the *A* will simply be discarded.\n \"\"\"\n # Gray must be a string to distinguish 3-4 grays from RGB or RGBA.\n\n try:\n return self.cache[arg]\n except KeyError:\n pass\n except TypeError: # could be unhashable rgb seq\n arg = tuple(arg)\n try:\n return self.cache[arg]\n except KeyError:\n pass\n except TypeError:\n raise ValueError(\n 'to_rgb: arg \"%s\" is unhashable even inside a tuple'\n % (str(arg),))\n\n try:\n if cbook.is_string_like(arg):\n argl = arg.lower()\n color = self.colors.get(argl, None)\n if color is None:\n str1 = cnames.get(argl, argl)\n if str1.startswith('#'):\n color = hex2color(str1)\n else:\n fl = float(argl)\n if fl < 0 or fl > 1:\n raise ValueError(\n 'gray (string) must be in range 0-1')\n color = (fl,)*3\n elif cbook.iterable(arg):\n if len(arg) > 4 or len(arg) < 3:\n raise ValueError(\n 'sequence length is %d; must be 3 or 4' % len(arg))\n color = tuple(arg[:3])\n if [x for x in color if (float(x) < 0) or (x > 1)]:\n # This will raise TypeError if x is not a number.\n raise ValueError(\n 'number in rbg sequence outside 0-1 range')\n else:\n raise ValueError(\n 'cannot convert argument to rgb sequence')\n\n self.cache[arg] = color\n\n except (KeyError, ValueError, TypeError) as exc:\n raise ValueError(\n 'to_rgb: Invalid rgb arg \"%s\"\\n%s' % (str(arg), exc))\n # Error messages could be improved by handling TypeError\n # separately; but this should be rare and not too hard\n # for the user to figure out as-is.\n return color\n\n def to_rgba(self, arg, alpha=None):\n \"\"\"\n Returns an *RGBA* tuple of four floats from 0-1.\n\n For acceptable values of *arg*, see :meth:`to_rgb`.\n In addition, if *arg* is \"none\" (case-insensitive),\n then (0,0,0,0) will be returned.\n If *arg* is an *RGBA* sequence and *alpha* is not *None*,\n *alpha* will replace the original *A*.\n \"\"\"\n try:\n if arg.lower() == 'none':\n return (0.0, 0.0, 0.0, 0.0)\n except AttributeError:\n pass\n\n try:\n if not cbook.is_string_like(arg) and cbook.iterable(arg):\n if len(arg) == 4:\n if [x for x in arg if (float(x) < 0) or (x > 1)]:\n # This will raise TypeError if x is not a number.\n raise ValueError(\n 'number in rbga sequence outside 0-1 range')\n if alpha is None:\n return tuple(arg)\n if alpha < 0.0 or alpha > 1.0:\n raise ValueError(\"alpha must be in range 0-1\")\n return arg[0], arg[1], arg[2], alpha\n r, g, b = arg[:3]\n if [x for x in (r, g, b) if (float(x) < 0) or (x > 1)]:\n raise ValueError(\n 'number in rbg sequence outside 0-1 range')\n else:\n r, g, b = self.to_rgb(arg)\n if alpha is None:\n alpha = 1.0\n return r, g, b, alpha\n except (TypeError, ValueError) as exc:\n raise ValueError(\n 'to_rgba: Invalid rgba arg \"%s\"\\n%s' % (str(arg), exc))\n\n def to_rgba_array(self, c, alpha=None):\n \"\"\"\n Returns a numpy array of *RGBA* tuples.\n\n Accepts a single mpl color spec or a sequence of specs.\n\n Special case to handle \"no color\": if *c* is \"none\" (case-insensitive),\n then an empty array will be returned. Same for an empty list.\n \"\"\"\n try:\n nc = len(c)\n except TypeError:\n raise ValueError(\n \"Cannot convert argument type %s to rgba array\" % type(c))\n try:\n if nc == 0 or c.lower() == 'none':\n return np.zeros((0, 4), dtype=np.float)\n except AttributeError:\n pass\n try:\n # Single value? Put it in an array with a single row.\n return np.array([self.to_rgba(c, alpha)], dtype=np.float)\n except ValueError:\n if isinstance(c, np.ndarray):\n if c.ndim != 2 and c.dtype.kind not in 'SU':\n raise ValueError(\"Color array must be two-dimensional\")\n if (c.ndim == 2 and c.shape[1] == 4 and c.dtype.kind == 'f'):\n if (c.ravel() > 1).any() or (c.ravel() < 0).any():\n raise ValueError(\n \"number in rgba sequence is outside 0-1 range\")\n result = np.asarray(c, np.float)\n if alpha is not None:\n if alpha > 1 or alpha < 0:\n raise ValueError(\"alpha must be in 0-1 range\")\n result[:, 3] = alpha\n return result\n # This alpha operation above is new, and depends\n # on higher levels to refrain from setting alpha\n # to values other than None unless there is\n # intent to override any existing alpha values.\n\n # It must be some other sequence of color specs.\n result = np.zeros((nc, 4), dtype=np.float)\n for i, cc in enumerate(c):\n result[i] = self.to_rgba(cc, alpha)\n return result\n\n\ncolorConverter = ColorConverter()\n\n\ndef makeMappingArray(N, data, gamma=1.0):\n \"\"\"Create an *N* -element 1-d lookup table\n\n *data* represented by a list of x,y0,y1 mapping correspondences.\n Each element in this list represents how a value between 0 and 1\n (inclusive) represented by x is mapped to a corresponding value\n between 0 and 1 (inclusive). The two values of y are to allow\n for discontinuous mapping functions (say as might be found in a\n sawtooth) where y0 represents the value of y for values of x\n <= to that given, and y1 is the value to be used for x > than\n that given). The list must start with x=0, end with x=1, and\n all values of x must be in increasing order. Values between\n the given mapping points are determined by simple linear interpolation.\n\n Alternatively, data can be a function mapping values between 0 - 1\n to 0 - 1.\n\n The function returns an array \"result\" where ``result[x*(N-1)]``\n gives the closest value for values of x between 0 and 1.\n \"\"\"\n\n if six.callable(data):\n xind = np.linspace(0, 1, N) ** gamma\n lut = np.clip(np.array(data(xind), dtype=np.float), 0, 1)\n return lut\n\n try:\n adata = np.array(data)\n except:\n raise TypeError(\"data must be convertable to an array\")\n shape = adata.shape\n if len(shape) != 2 and shape[1] != 3:\n raise ValueError(\"data must be nx3 format\")\n\n x = adata[:, 0]\n y0 = adata[:, 1]\n y1 = adata[:, 2]\n\n if x[0] != 0. or x[-1] != 1.0:\n raise ValueError(\n \"data mapping points must start with x=0. and end with x=1\")\n if np.sometrue(np.sort(x) - x):\n raise ValueError(\n \"data mapping points must have x in increasing order\")\n # begin generation of lookup table\n x = x * (N - 1)\n lut = np.zeros((N,), np.float)\n xind = (N - 1) * np.linspace(0, 1, N) ** gamma\n ind = np.searchsorted(x, xind)[1:-1]\n\n lut[1:-1] = (((xind[1:-1] - x[ind - 1]) / (x[ind] - x[ind - 1])) *\n (y0[ind] - y1[ind - 1]) + y1[ind - 1])\n lut[0] = y1[0]\n lut[-1] = y0[-1]\n # ensure that the lut is confined to values between 0 and 1 by clipping it\n np.clip(lut, 0.0, 1.0)\n #lut = where(lut > 1., 1., lut)\n #lut = where(lut < 0., 0., lut)\n return lut\n\n\nclass Colormap(object):\n \"\"\"\n Baseclass for all scalar to RGBA mappings.\n\n Typically Colormap instances are used to convert data values (floats) from\n the interval ``[0, 1]`` to the RGBA color that the respective Colormap\n represents. For scaling of data into the ``[0, 1]`` interval see\n :class:`matplotlib.colors.Normalize`. It is worth noting that\n :class:`matplotlib.cm.ScalarMappable` subclasses make heavy use of this\n ``data->normalize->map-to-color`` processing chain.\n\n \"\"\"\n def __init__(self, name, N=256):\n r\"\"\"\n Parameters\n ----------\n name : str\n The name of the colormap.\n N : int\n The number of rgb quantization levels.\n\n \"\"\"\n self.name = name\n self.N = int(N) # ensure that N is always int\n self._rgba_bad = (0.0, 0.0, 0.0, 0.0) # If bad, don't paint anything.\n self._rgba_under = None\n self._rgba_over = None\n self._i_under = self.N\n self._i_over = self.N + 1\n self._i_bad = self.N + 2\n self._isinit = False\n\n #: When this colormap exists on a scalar mappable and colorbar_extend\n #: is not False, colorbar creation will pick up ``colorbar_extend`` as\n #: the default value for the ``extend`` keyword in the\n #: :class:`matplotlib.colorbar.Colorbar` constructor.\n self.colorbar_extend = False\n\n def __call__(self, X, alpha=None, bytes=False):\n \"\"\"\n Parameters\n ----------\n X : scalar, ndarray\n The data value(s) to convert to RGBA.\n For floats, X should be in the interval ``[0.0, 1.0]`` to\n return the RGBA values ``X*100`` percent along the Colormap line.\n For integers, X should be in the interval ``[0, Colormap.N)`` to\n return RGBA values *indexed* from the Colormap with index ``X``.\n alpha : float, None\n Alpha must be a scalar between 0 and 1, or None.\n bytes : bool\n If False (default), the returned RGBA values will be floats in the\n interval ``[0, 1]`` otherwise they will be uint8s in the interval\n ``[0, 255]``.\n\n Returns\n -------\n Tuple of RGBA values if X is scalar, othewise an array of\n RGBA values with a shape of ``X.shape + (4, )``.\n\n \"\"\"\n # See class docstring for arg/kwarg documentation.\n if not self._isinit:\n self._init()\n mask_bad = None\n if not cbook.iterable(X):\n vtype = 'scalar'\n xa = np.array([X])\n else:\n vtype = 'array'\n xma = ma.array(X, copy=True) # Copy here to avoid side effects.\n mask_bad = xma.mask # Mask will be used below.\n xa = xma.filled() # Fill to avoid infs, etc.\n del xma\n\n # Calculations with native byteorder are faster, and avoid a\n # bug that otherwise can occur with putmask when the last\n # argument is a numpy scalar.\n if not xa.dtype.isnative:\n xa = xa.byteswap().newbyteorder()\n\n if xa.dtype.kind == \"f\":\n # Treat 1.0 as slightly less than 1.\n vals = np.array([1, 0], dtype=xa.dtype)\n almost_one = np.nextafter(*vals)\n cbook._putmask(xa, xa == 1.0, almost_one)\n # The following clip is fast, and prevents possible\n # conversion of large positive values to negative integers.\n\n xa *= self.N\n if NP_CLIP_OUT:\n np.clip(xa, -1, self.N, out=xa)\n else:\n xa = np.clip(xa, -1, self.N)\n\n # ensure that all 'under' values will still have negative\n # value after casting to int\n cbook._putmask(xa, xa < 0.0, -1)\n xa = xa.astype(int)\n # Set the over-range indices before the under-range;\n # otherwise the under-range values get converted to over-range.\n cbook._putmask(xa, xa > self.N - 1, self._i_over)\n cbook._putmask(xa, xa < 0, self._i_under)\n if mask_bad is not None:\n if mask_bad.shape == xa.shape:\n cbook._putmask(xa, mask_bad, self._i_bad)\n elif mask_bad:\n xa.fill(self._i_bad)\n if bytes:\n lut = (self._lut * 255).astype(np.uint8)\n else:\n lut = self._lut.copy() # Don't let alpha modify original _lut.\n\n if alpha is not None:\n alpha = min(alpha, 1.0) # alpha must be between 0 and 1\n alpha = max(alpha, 0.0)\n if bytes:\n alpha = int(alpha * 255)\n if (lut[-1] == 0).all():\n lut[:-1, -1] = alpha\n # All zeros is taken as a flag for the default bad\n # color, which is no color--fully transparent. We\n # don't want to override this.\n else:\n lut[:, -1] = alpha\n # If the bad value is set to have a color, then we\n # override its alpha just as for any other value.\n\n rgba = np.empty(shape=xa.shape + (4,), dtype=lut.dtype)\n lut.take(xa, axis=0, mode='clip', out=rgba)\n # twice as fast as lut[xa];\n # using the clip or wrap mode and providing an\n # output array speeds it up a little more.\n if vtype == 'scalar':\n rgba = tuple(rgba[0, :])\n return rgba\n\n def set_bad(self, color='k', alpha=None):\n '''Set color to be used for masked values.\n '''\n self._rgba_bad = colorConverter.to_rgba(color, alpha)\n if self._isinit:\n self._set_extremes()\n\n def set_under(self, color='k', alpha=None):\n '''Set color to be used for low out-of-range values.\n Requires norm.clip = False\n '''\n self._rgba_under = colorConverter.to_rgba(color, alpha)\n if self._isinit:\n self._set_extremes()\n\n def set_over(self, color='k', alpha=None):\n '''Set color to be used for high out-of-range values.\n Requires norm.clip = False\n '''\n self._rgba_over = colorConverter.to_rgba(color, alpha)\n if self._isinit:\n self._set_extremes()\n\n def _set_extremes(self):\n if self._rgba_under:\n self._lut[self._i_under] = self._rgba_under\n else:\n self._lut[self._i_under] = self._lut[0]\n if self._rgba_over:\n self._lut[self._i_over] = self._rgba_over\n else:\n self._lut[self._i_over] = self._lut[self.N - 1]\n self._lut[self._i_bad] = self._rgba_bad\n\n def _init(self):\n '''Generate the lookup table, self._lut'''\n raise NotImplementedError(\"Abstract class only\")\n\n def is_gray(self):\n if not self._isinit:\n self._init()\n return (np.alltrue(self._lut[:, 0] == self._lut[:, 1]) and\n np.alltrue(self._lut[:, 0] == self._lut[:, 2]))\n\n\nclass LinearSegmentedColormap(Colormap):\n \"\"\"Colormap objects based on lookup tables using linear segments.\n\n The lookup table is generated using linear interpolation for each\n primary color, with the 0-1 domain divided into any number of\n segments.\n \"\"\"\n def __init__(self, name, segmentdata, N=256, gamma=1.0):\n \"\"\"Create color map from linear mapping segments\n\n segmentdata argument is a dictionary with a red, green and blue\n entries. Each entry should be a list of *x*, *y0*, *y1* tuples,\n forming rows in a table. Entries for alpha are optional.\n\n Example: suppose you want red to increase from 0 to 1 over\n the bottom half, green to do the same over the middle half,\n and blue over the top half. Then you would use::\n\n cdict = {'red': [(0.0, 0.0, 0.0),\n (0.5, 1.0, 1.0),\n (1.0, 1.0, 1.0)],\n\n 'green': [(0.0, 0.0, 0.0),\n (0.25, 0.0, 0.0),\n (0.75, 1.0, 1.0),\n (1.0, 1.0, 1.0)],\n\n 'blue': [(0.0, 0.0, 0.0),\n (0.5, 0.0, 0.0),\n (1.0, 1.0, 1.0)]}\n\n Each row in the table for a given color is a sequence of\n *x*, *y0*, *y1* tuples. In each sequence, *x* must increase\n monotonically from 0 to 1. For any input value *z* falling\n between *x[i]* and *x[i+1]*, the output value of a given color\n will be linearly interpolated between *y1[i]* and *y0[i+1]*::\n\n row i: x y0 y1\n /\n /\n row i+1: x y0 y1\n\n Hence y0 in the first row and y1 in the last row are never used.\n\n\n .. seealso::\n\n :meth:`LinearSegmentedColormap.from_list`\n Static method; factory function for generating a\n smoothly-varying LinearSegmentedColormap.\n\n :func:`makeMappingArray`\n For information about making a mapping array.\n \"\"\"\n # True only if all colors in map are identical; needed for contouring.\n self.monochrome = False\n Colormap.__init__(self, name, N)\n self._segmentdata = segmentdata\n self._gamma = gamma\n\n def _init(self):\n self._lut = np.ones((self.N + 3, 4), np.float)\n self._lut[:-3, 0] = makeMappingArray(\n self.N, self._segmentdata['red'], self._gamma)\n self._lut[:-3, 1] = makeMappingArray(\n self.N, self._segmentdata['green'], self._gamma)\n self._lut[:-3, 2] = makeMappingArray(\n self.N, self._segmentdata['blue'], self._gamma)\n if 'alpha' in self._segmentdata:\n self._lut[:-3, 3] = makeMappingArray(\n self.N, self._segmentdata['alpha'], 1)\n self._isinit = True\n self._set_extremes()\n\n def set_gamma(self, gamma):\n \"\"\"\n Set a new gamma value and regenerate color map.\n \"\"\"\n self._gamma = gamma\n self._init()\n\n @staticmethod\n def from_list(name, colors, N=256, gamma=1.0):\n \"\"\"\n Make a linear segmented colormap with *name* from a sequence\n of *colors* which evenly transitions from colors[0] at val=0\n to colors[-1] at val=1. *N* is the number of rgb quantization\n levels.\n Alternatively, a list of (value, color) tuples can be given\n to divide the range unevenly.\n \"\"\"\n\n if not cbook.iterable(colors):\n raise ValueError('colors must be iterable')\n\n if cbook.iterable(colors[0]) and len(colors[0]) == 2 and \\\n not cbook.is_string_like(colors[0]):\n # List of value, color pairs\n vals, colors = list(zip(*colors))\n else:\n vals = np.linspace(0., 1., len(colors))\n\n cdict = dict(red=[], green=[], blue=[], alpha=[])\n for val, color in zip(vals, colors):\n r, g, b, a = colorConverter.to_rgba(color)\n cdict['red'].append((val, r, r))\n cdict['green'].append((val, g, g))\n cdict['blue'].append((val, b, b))\n cdict['alpha'].append((val, a, a))\n\n return LinearSegmentedColormap(name, cdict, N, gamma)\n\n\nclass ListedColormap(Colormap):\n \"\"\"Colormap object generated from a list of colors.\n\n This may be most useful when indexing directly into a colormap,\n but it can also be used to generate special colormaps for ordinary\n mapping.\n \"\"\"\n def __init__(self, colors, name='from_list', N=None):\n \"\"\"\n Make a colormap from a list of colors.\n\n *colors*\n a list of matplotlib color specifications,\n or an equivalent Nx3 or Nx4 floating point array\n (*N* rgb or rgba values)\n *name*\n a string to identify the colormap\n *N*\n the number of entries in the map. The default is *None*,\n in which case there is one colormap entry for each\n element in the list of colors. If::\n\n N < len(colors)\n\n the list will be truncated at *N*. If::\n\n N > len(colors)\n\n the list will be extended by repetition.\n \"\"\"\n self.colors = colors\n self.monochrome = False # True only if all colors in map are\n # identical; needed for contouring.\n if N is None:\n N = len(self.colors)\n else:\n if cbook.is_string_like(self.colors):\n self.colors = [self.colors] * N\n self.monochrome = True\n elif cbook.iterable(self.colors):\n self.colors = list(self.colors) # in case it was a tuple\n if len(self.colors) == 1:\n self.monochrome = True\n if len(self.colors) < N:\n self.colors = list(self.colors) * N\n del(self.colors[N:])\n else:\n try:\n gray = float(self.colors)\n except TypeError:\n pass\n else:\n self.colors = [gray] * N\n self.monochrome = True\n Colormap.__init__(self, name, N)\n\n def _init(self):\n rgba = colorConverter.to_rgba_array(self.colors)\n self._lut = np.zeros((self.N + 3, 4), np.float)\n self._lut[:-3] = rgba\n self._isinit = True\n self._set_extremes()\n\n\nclass Normalize(object):\n \"\"\"\n A class which, when called, can normalize data into\n the ``[0.0, 1.0]`` interval.\n\n \"\"\"\n def __init__(self, vmin=None, vmax=None, clip=False):\n \"\"\"\n If *vmin* or *vmax* is not given, they are taken from the input's\n minimum and maximum value respectively. If *clip* is *True* and\n the given value falls outside the range, the returned value\n will be 0 or 1, whichever is closer. Returns 0 if::\n\n vmin==vmax\n\n Works with scalars or arrays, including masked arrays. If\n *clip* is *True*, masked values are set to 1; otherwise they\n remain masked. Clipping silently defeats the purpose of setting\n the over, under, and masked colors in the colormap, so it is\n likely to lead to surprises; therefore the default is\n *clip* = *False*.\n \"\"\"\n self.vmin = vmin\n self.vmax = vmax\n self.clip = clip\n\n @staticmethod\n def process_value(value):\n \"\"\"\n Homogenize the input *value* for easy and efficient normalization.\n\n *value* can be a scalar or sequence.\n\n Returns *result*, *is_scalar*, where *result* is a\n masked array matching *value*. Float dtypes are preserved;\n integer types with two bytes or smaller are converted to\n np.float32, and larger types are converted to np.float.\n Preserving float32 when possible, and using in-place operations,\n can greatly improve speed for large arrays.\n\n Experimental; we may want to add an option to force the\n use of float32.\n \"\"\"\n if cbook.iterable(value):\n is_scalar = False\n result = ma.asarray(value)\n if result.dtype.kind == 'f':\n if isinstance(value, np.ndarray):\n result = result.copy()\n elif result.dtype.itemsize > 2:\n result = result.astype(np.float)\n else:\n result = result.astype(np.float32)\n else:\n is_scalar = True\n result = ma.array([value]).astype(np.float)\n return result, is_scalar\n\n def __call__(self, value, clip=None):\n if clip is None:\n clip = self.clip\n\n result, is_scalar = self.process_value(value)\n\n self.autoscale_None(result)\n vmin, vmax = self.vmin, self.vmax\n if vmin == vmax:\n result.fill(0) # Or should it be all masked? Or 0.5?\n elif vmin > vmax:\n raise ValueError(\"minvalue must be less than or equal to maxvalue\")\n else:\n vmin = float(vmin)\n vmax = float(vmax)\n if clip:\n mask = ma.getmask(result)\n result = ma.array(np.clip(result.filled(vmax), vmin, vmax),\n mask=mask)\n # ma division is very slow; we can take a shortcut\n resdat = result.data\n resdat -= vmin\n resdat /= (vmax - vmin)\n result = np.ma.array(resdat, mask=result.mask, copy=False)\n if is_scalar:\n result = result[0]\n return result\n\n def inverse(self, value):\n if not self.scaled():\n raise ValueError(\"Not invertible until scaled\")\n vmin = float(self.vmin)\n vmax = float(self.vmax)\n\n if cbook.iterable(value):\n val = ma.asarray(value)\n return vmin + val * (vmax - vmin)\n else:\n return vmin + value * (vmax - vmin)\n\n def autoscale(self, A):\n '''\n Set *vmin*, *vmax* to min, max of *A*.\n '''\n self.vmin = ma.min(A)\n self.vmax = ma.max(A)\n\n def autoscale_None(self, A):\n ' autoscale only None-valued vmin or vmax'\n if self.vmin is None and np.size(A) > 0:\n self.vmin = ma.min(A)\n if self.vmax is None and np.size(A) > 0:\n self.vmax = ma.max(A)\n\n def scaled(self):\n 'return true if vmin and vmax set'\n return (self.vmin is not None and self.vmax is not None)\n\n\nclass LogNorm(Normalize):\n \"\"\"\n Normalize a given value to the 0-1 range on a log scale\n \"\"\"\n def __call__(self, value, clip=None):\n if clip is None:\n clip = self.clip\n\n result, is_scalar = self.process_value(value)\n\n result = ma.masked_less_equal(result, 0, copy=False)\n\n self.autoscale_None(result)\n vmin, vmax = self.vmin, self.vmax\n if vmin > vmax:\n raise ValueError(\"minvalue must be less than or equal to maxvalue\")\n elif vmin <= 0:\n raise ValueError(\"values must all be positive\")\n elif vmin == vmax:\n result.fill(0)\n else:\n if clip:\n mask = ma.getmask(result)\n result = ma.array(np.clip(result.filled(vmax), vmin, vmax),\n mask=mask)\n # in-place equivalent of above can be much faster\n resdat = result.data\n mask = result.mask\n if mask is np.ma.nomask:\n mask = (resdat <= 0)\n else:\n mask |= resdat <= 0\n cbook._putmask(resdat, mask, 1)\n np.log(resdat, resdat)\n resdat -= np.log(vmin)\n resdat /= (np.log(vmax) - np.log(vmin))\n result = np.ma.array(resdat, mask=mask, copy=False)\n if is_scalar:\n result = result[0]\n return result\n\n def inverse(self, value):\n if not self.scaled():\n raise ValueError(\"Not invertible until scaled\")\n vmin, vmax = self.vmin, self.vmax\n\n if cbook.iterable(value):\n val = ma.asarray(value)\n return vmin * ma.power((vmax / vmin), val)\n else:\n return vmin * pow((vmax / vmin), value)\n\n def autoscale(self, A):\n '''\n Set *vmin*, *vmax* to min, max of *A*.\n '''\n A = ma.masked_less_equal(A, 0, copy=False)\n self.vmin = ma.min(A)\n self.vmax = ma.max(A)\n\n def autoscale_None(self, A):\n ' autoscale only None-valued vmin or vmax'\n if self.vmin is not None and self.vmax is not None:\n return\n A = ma.masked_less_equal(A, 0, copy=False)\n if self.vmin is None:\n self.vmin = ma.min(A)\n if self.vmax is None:\n self.vmax = ma.max(A)\n\n\nclass SymLogNorm(Normalize):\n \"\"\"\n The symmetrical logarithmic scale is logarithmic in both the\n positive and negative directions from the origin.\n\n Since the values close to zero tend toward infinity, there is a\n need to have a range around zero that is linear. The parameter\n *linthresh* allows the user to specify the size of this range\n (-*linthresh*, *linthresh*).\n \"\"\"\n def __init__(self, linthresh, linscale=1.0,\n vmin=None, vmax=None, clip=False):\n \"\"\"\n *linthresh*:\n The range within which the plot is linear (to\n avoid having the plot go to infinity around zero).\n\n *linscale*:\n This allows the linear range (-*linthresh* to *linthresh*)\n to be stretched relative to the logarithmic range. Its\n value is the number of decades to use for each half of the\n linear range. For example, when *linscale* == 1.0 (the\n default), the space used for the positive and negative\n halves of the linear range will be equal to one decade in\n the logarithmic range. Defaults to 1.\n \"\"\"\n Normalize.__init__(self, vmin, vmax, clip)\n self.linthresh = float(linthresh)\n self._linscale_adj = (linscale / (1.0 - np.e ** -1))\n\n def __call__(self, value, clip=None):\n if clip is None:\n clip = self.clip\n\n result, is_scalar = self.process_value(value)\n self.autoscale_None(result)\n vmin, vmax = self.vmin, self.vmax\n\n if vmin > vmax:\n raise ValueError(\"minvalue must be less than or equal to maxvalue\")\n elif vmin == vmax:\n result.fill(0)\n else:\n if clip:\n mask = ma.getmask(result)\n result = ma.array(np.clip(result.filled(vmax), vmin, vmax),\n mask=mask)\n # in-place equivalent of above can be much faster\n resdat = self._transform(result.data)\n resdat -= self._lower\n resdat /= (self._upper - self._lower)\n\n if is_scalar:\n result = result[0]\n return result\n\n def _transform(self, a):\n \"\"\"\n Inplace transformation.\n \"\"\"\n masked = np.abs(a) > self.linthresh\n sign = np.sign(a[masked])\n log = (self._linscale_adj + np.log(np.abs(a[masked]) / self.linthresh))\n log *= sign * self.linthresh\n a[masked] = log\n a[~masked] *= self._linscale_adj\n return a\n\n def _inv_transform(self, a):\n \"\"\"\n Inverse inplace Transformation.\n \"\"\"\n masked = np.abs(a) > (self.linthresh * self._linscale_adj)\n sign = np.sign(a[masked])\n exp = np.exp(sign * a[masked] / self.linthresh - self._linscale_adj)\n exp *= sign * self.linthresh\n a[masked] = exp\n a[~masked] /= self._linscale_adj\n return a\n\n def _transform_vmin_vmax(self):\n \"\"\"\n Calculates vmin and vmax in the transformed system.\n \"\"\"\n vmin, vmax = self.vmin, self.vmax\n arr = np.array([vmax, vmin]).astype(np.float)\n self._upper, self._lower = self._transform(arr)\n\n def inverse(self, value):\n if not self.scaled():\n raise ValueError(\"Not invertible until scaled\")\n val = ma.asarray(value)\n val = val * (self._upper - self._lower) + self._lower\n return self._inv_transform(val)\n\n def autoscale(self, A):\n \"\"\"\n Set *vmin*, *vmax* to min, max of *A*.\n \"\"\"\n self.vmin = ma.min(A)\n self.vmax = ma.max(A)\n self._transform_vmin_vmax()\n\n def autoscale_None(self, A):\n \"\"\" autoscale only None-valued vmin or vmax \"\"\"\n if self.vmin is not None and self.vmax is not None:\n pass\n if self.vmin is None:\n self.vmin = ma.min(A)\n if self.vmax is None:\n self.vmax = ma.max(A)\n self._transform_vmin_vmax()\n\n\nclass BoundaryNorm(Normalize):\n '''\n Generate a colormap index based on discrete intervals.\n\n Unlike :class:`Normalize` or :class:`LogNorm`,\n :class:`BoundaryNorm` maps values to integers instead of to the\n interval 0-1.\n\n Mapping to the 0-1 interval could have been done via\n piece-wise linear interpolation, but using integers seems\n simpler, and reduces the number of conversions back and forth\n between integer and floating point.\n '''\n def __init__(self, boundaries, ncolors, clip=False):\n '''\n *boundaries*\n a monotonically increasing sequence\n *ncolors*\n number of colors in the colormap to be used\n\n If::\n\n b[i] <= v < b[i+1]\n\n then v is mapped to color j;\n as i varies from 0 to len(boundaries)-2,\n j goes from 0 to ncolors-1.\n\n Out-of-range values are mapped to -1 if low and ncolors\n if high; these are converted to valid indices by\n :meth:`Colormap.__call__` .\n '''\n self.clip = clip\n self.vmin = boundaries[0]\n self.vmax = boundaries[-1]\n self.boundaries = np.asarray(boundaries)\n self.N = len(self.boundaries)\n self.Ncmap = ncolors\n if self.N - 1 == self.Ncmap:\n self._interp = False\n else:\n self._interp = True\n\n def __call__(self, x, clip=None):\n if clip is None:\n clip = self.clip\n x = ma.asarray(x)\n mask = ma.getmaskarray(x)\n xx = x.filled(self.vmax + 1)\n if clip:\n np.clip(xx, self.vmin, self.vmax)\n iret = np.zeros(x.shape, dtype=np.int16)\n for i, b in enumerate(self.boundaries):\n iret[xx >= b] = i\n if self._interp:\n scalefac = float(self.Ncmap - 1) / (self.N - 2)\n iret = (iret * scalefac).astype(np.int16)\n iret[xx < self.vmin] = -1\n iret[xx >= self.vmax] = self.Ncmap\n ret = ma.array(iret, mask=mask)\n if ret.shape == () and not mask:\n ret = int(ret) # assume python scalar\n return ret\n\n def inverse(self, value):\n return ValueError(\"BoundaryNorm is not invertible\")\n\n\nclass NoNorm(Normalize):\n '''\n Dummy replacement for Normalize, for the case where we\n want to use indices directly in a\n :class:`~matplotlib.cm.ScalarMappable` .\n '''\n def __call__(self, value, clip=None):\n return value\n\n def inverse(self, value):\n return value\n\n# compatibility with earlier class names that violated convention:\nnormalize = cbook.deprecated('1.3', alternative='Normalize',\n name='normalize',\n obj_type='class alias')(Normalize)\nno_norm = cbook.deprecated('1.3', alternative='NoNorm',\n name='no_norm',\n obj_type='class alias')(NoNorm)\n\n\ndef rgb_to_hsv(arr):\n \"\"\"\n convert float rgb values (in the range [0, 1]), in a numpy array to hsv\n values.\n\n Parameters\n ----------\n arr : (..., 3) array-like\n All values must be in the range [0, 1]\n\n Returns\n -------\n hsv : (..., 3) ndarray\n Colors converted to hsv values in range [0, 1]\n \"\"\"\n # make sure it is an ndarray\n arr = np.asarray(arr)\n\n # check length of the last dimension, should be _some_ sort of rgb\n if arr.shape[-1] != 3:\n raise ValueError(\"Last dimension of input array must be 3; \"\n \"shape {shp} was found.\".format(shp=arr.shape))\n\n in_ndim = arr.ndim\n if arr.ndim == 1:\n arr = np.array(arr, ndmin=2)\n\n # make sure we don't have an int image\n if arr.dtype.kind in ('iu'):\n arr = arr.astype(np.float32)\n\n out = np.zeros_like(arr)\n arr_max = arr.max(-1)\n ipos = arr_max > 0\n delta = arr.ptp(-1)\n s = np.zeros_like(delta)\n s[ipos] = delta[ipos] / arr_max[ipos]\n ipos = delta > 0\n # red is max\n idx = (arr[..., 0] == arr_max) & ipos\n out[idx, 0] = (arr[idx, 1] - arr[idx, 2]) / delta[idx]\n # green is max\n idx = (arr[..., 1] == arr_max) & ipos\n out[idx, 0] = 2. + (arr[idx, 2] - arr[idx, 0]) / delta[idx]\n # blue is max\n idx = (arr[..., 2] == arr_max) & ipos\n out[idx, 0] = 4. + (arr[idx, 0] - arr[idx, 1]) / delta[idx]\n\n out[..., 0] = (out[..., 0] / 6.0) % 1.0\n out[..., 1] = s\n out[..., 2] = arr_max\n\n if in_ndim == 1:\n out.shape = (3,)\n\n return out\n\n\ndef hsv_to_rgb(hsv):\n \"\"\"\n convert hsv values in a numpy array to rgb values\n all values assumed to be in range [0, 1]\n\n Parameters\n ----------\n hsv : (..., 3) array-like\n All values assumed to be in range [0, 1]\n\n Returns\n -------\n rgb : (..., 3) ndarray\n Colors converted to RGB values in range [0, 1]\n \"\"\"\n # make sure it is an ndarray\n hsv = np.asarray(hsv)\n\n # check length of the last dimension, should be _some_ sort of rgb\n if hsv.shape[-1] != 3:\n raise ValueError(\"Last dimension of input array must be 3; \"\n \"shape {shp} was found.\".format(shp=hsv.shape))\n\n # if we got pased a 1D array, try to treat as\n # a single color and reshape as needed\n in_ndim = hsv.ndim\n if in_ndim == 1:\n hsv = np.array(hsv, ndmin=2)\n\n # make sure we don't have an int image\n if hsv.dtype.kind in ('iu'):\n hsv = hsv.astype(np.float32)\n\n h = hsv[..., 0]\n s = hsv[..., 1]\n v = hsv[..., 2]\n\n r = np.empty_like(h)\n g = np.empty_like(h)\n b = np.empty_like(h)\n\n i = (h * 6.0).astype(np.int)\n f = (h * 6.0) - i\n p = v * (1.0 - s)\n q = v * (1.0 - s * f)\n t = v * (1.0 - s * (1.0 - f))\n\n idx = i % 6 == 0\n r[idx] = v[idx]\n g[idx] = t[idx]\n b[idx] = p[idx]\n\n idx = i == 1\n r[idx] = q[idx]\n g[idx] = v[idx]\n b[idx] = p[idx]\n\n idx = i == 2\n r[idx] = p[idx]\n g[idx] = v[idx]\n b[idx] = t[idx]\n\n idx = i == 3\n r[idx] = p[idx]\n g[idx] = q[idx]\n b[idx] = v[idx]\n\n idx = i == 4\n r[idx] = t[idx]\n g[idx] = p[idx]\n b[idx] = v[idx]\n\n idx = i == 5\n r[idx] = v[idx]\n g[idx] = p[idx]\n b[idx] = q[idx]\n\n idx = s == 0\n r[idx] = v[idx]\n g[idx] = v[idx]\n b[idx] = v[idx]\n\n rgb = np.empty_like(hsv)\n rgb[..., 0] = r\n rgb[..., 1] = g\n rgb[..., 2] = b\n\n if in_ndim == 1:\n rgb.shape = (3, )\n\n return rgb\n\n\nclass LightSource(object):\n \"\"\"\n Create a light source coming from the specified azimuth and elevation.\n Angles are in degrees, with the azimuth measured\n clockwise from north and elevation up from the zero plane of the surface.\n The :meth:`shade` is used to produce rgb values for a shaded relief image\n given a data array.\n \"\"\"\n def __init__(self, azdeg=315, altdeg=45,\n hsv_min_val=0, hsv_max_val=1, hsv_min_sat=1,\n hsv_max_sat=0):\n\n \"\"\"\n Specify the azimuth (measured clockwise from south) and altitude\n (measured up from the plane of the surface) of the light source\n in degrees.\n\n The color of the resulting image will be darkened\n by moving the (s,v) values (in hsv colorspace) toward\n (hsv_min_sat, hsv_min_val) in the shaded regions, or\n lightened by sliding (s,v) toward\n (hsv_max_sat hsv_max_val) in regions that are illuminated.\n The default extremes are chose so that completely shaded points\n are nearly black (s = 1, v = 0) and completely illuminated points\n are nearly white (s = 0, v = 1).\n \"\"\"\n self.azdeg = azdeg\n self.altdeg = altdeg\n self.hsv_min_val = hsv_min_val\n self.hsv_max_val = hsv_max_val\n self.hsv_min_sat = hsv_min_sat\n self.hsv_max_sat = hsv_max_sat\n\n def shade(self, data, cmap, norm=None):\n \"\"\"\n Take the input data array, convert to HSV values in the\n given colormap, then adjust those color values\n to give the impression of a shaded relief map with a\n specified light source.\n RGBA values are returned, which can then be used to\n plot the shaded image with imshow.\n \"\"\"\n\n if norm is None:\n norm = Normalize(vmin=data.min(), vmax=data.max())\n\n rgb0 = cmap(norm(data))\n rgb1 = self.shade_rgb(rgb0, elevation=data)\n rgb0[:, :, 0:3] = rgb1\n return rgb0\n\n def shade_rgb(self, rgb, elevation, fraction=1.):\n \"\"\"\n Take the input RGB array (ny*nx*3) adjust their color values\n to given the impression of a shaded relief map with a\n specified light source using the elevation (ny*nx).\n A new RGB array ((ny*nx*3)) is returned.\n \"\"\"\n # imagine an artificial sun placed at infinity in some azimuth and\n # elevation position illuminating our surface. The parts of the\n # surface that slope toward the sun should brighten while those sides\n # facing away should become darker. convert alt, az to radians\n az = self.azdeg * np.pi / 180.0\n alt = self.altdeg * np.pi / 180.0\n # gradient in x and y directions\n dx, dy = np.gradient(elevation)\n slope = 0.5 * np.pi - np.arctan(np.hypot(dx, dy))\n aspect = np.arctan2(dx, dy)\n intensity = (np.sin(alt) * np.sin(slope) + np.cos(alt) *\n np.cos(slope) * np.cos(-az - aspect - 0.5 * np.pi))\n # rescale to interval -1,1\n # +1 means maximum sun exposure and -1 means complete shade.\n intensity = (intensity - intensity.min()) / \\\n (intensity.max() - intensity.min())\n intensity = (2. * intensity - 1.) * fraction\n # convert to rgb, then rgb to hsv\n #rgb = cmap((data-data.min())/(data.max()-data.min()))\n hsv = rgb_to_hsv(rgb[:, :, 0:3])\n # modify hsv values to simulate illumination.\n\n hsv[:, :, 1] = np.where(np.logical_and(np.abs(hsv[:, :, 1]) > 1.e-10,\n intensity > 0),\n ((1. - intensity) * hsv[:, :, 1] +\n intensity * self.hsv_max_sat),\n hsv[:, :, 1])\n\n hsv[:, :, 2] = np.where(intensity > 0,\n ((1. - intensity) * hsv[:, :, 2] +\n intensity * self.hsv_max_val),\n hsv[:, :, 2])\n\n hsv[:, :, 1] = np.where(np.logical_and(np.abs(hsv[:, :, 1]) > 1.e-10,\n intensity < 0),\n ((1. + intensity) * hsv[:, :, 1] -\n intensity * self.hsv_min_sat),\n hsv[:, :, 1])\n hsv[:, :, 2] = np.where(intensity < 0,\n ((1. + intensity) * hsv[:, :, 2] -\n intensity * self.hsv_min_val),\n hsv[:, :, 2])\n hsv[:, :, 1:] = np.where(hsv[:, :, 1:] < 0., 0, hsv[:, :, 1:])\n hsv[:, :, 1:] = np.where(hsv[:, :, 1:] > 1., 1, hsv[:, :, 1:])\n # convert modified hsv back to rgb.\n return hsv_to_rgb(hsv)\n\n\ndef from_levels_and_colors(levels, colors, extend='neither'):\n \"\"\"\n A helper routine to generate a cmap and a norm instance which\n behave similar to contourf's levels and colors arguments.\n\n Parameters\n ----------\n levels : sequence of numbers\n The quantization levels used to construct the :class:`BoundaryNorm`.\n Values ``v`` are quantizized to level ``i`` if\n ``lev[i] <= v < lev[i+1]``.\n colors : sequence of colors\n The fill color to use for each level. If `extend` is \"neither\" there\n must be ``n_level - 1`` colors. For an `extend` of \"min\" or \"max\" add\n one extra color, and for an `extend` of \"both\" add two colors.\n extend : {'neither', 'min', 'max', 'both'}, optional\n The behaviour when a value falls out of range of the given levels.\n See :func:`~matplotlib.pyplot.contourf` for details.\n\n Returns\n -------\n (cmap, norm) : tuple containing a :class:`Colormap` and a \\\n :class:`Normalize` instance\n \"\"\"\n colors_i0 = 0\n colors_i1 = None\n\n if extend == 'both':\n colors_i0 = 1\n colors_i1 = -1\n extra_colors = 2\n elif extend == 'min':\n colors_i0 = 1\n extra_colors = 1\n elif extend == 'max':\n colors_i1 = -1\n extra_colors = 1\n elif extend == 'neither':\n extra_colors = 0\n else:\n raise ValueError('Unexpected value for extend: {0!r}'.format(extend))\n\n n_data_colors = len(levels) - 1\n n_expected_colors = n_data_colors + extra_colors\n if len(colors) != n_expected_colors:\n raise ValueError('With extend == {0!r} and n_levels == {1!r} expected'\n ' n_colors == {2!r}. Got {3!r}.'\n ''.format(extend, len(levels), n_expected_colors,\n len(colors)))\n\n cmap = ListedColormap(colors[colors_i0:colors_i1], N=n_data_colors)\n\n if extend in ['min', 'both']:\n cmap.set_under(colors[0])\n else:\n cmap.set_under('none')\n\n if extend in ['max', 'both']:\n cmap.set_over(colors[-1])\n else:\n cmap.set_over('none')\n\n cmap.colorbar_extend = extend\n\n norm = BoundaryNorm(levels, ncolors=n_data_colors)\n return cmap, norm\n",
"#!/usr/bin/env python\nimport numpy as np\nfrom basic_units import cm, inch\nimport matplotlib.pyplot as plt\n\n\nN = 5\nmenMeans = (150*cm, 160*cm, 146*cm, 172*cm, 155*cm)\nmenStd = ( 20*cm, 30*cm, 32*cm, 10*cm, 20*cm)\n\nfig, ax = plt.subplots()\n\nind = np.arange(N) # the x locations for the groups\nwidth = 0.35 # the width of the bars\np1 = ax.bar(ind, menMeans, width, color='r', bottom=0*cm, yerr=menStd)\n\n\nwomenMeans = (145*cm, 149*cm, 172*cm, 165*cm, 200*cm)\nwomenStd = (30*cm, 25*cm, 20*cm, 31*cm, 22*cm)\np2 = ax.bar(ind+width, womenMeans, width, color='y', bottom=0*cm, yerr=womenStd)\n\nax.set_title('Scores by group and gender')\nax.set_xticks(ind+width)\nax.set_xticklabels( ('G1', 'G2', 'G3', 'G4', 'G5') )\n\nax.legend( (p1[0], p2[0]), ('Men', 'Women') )\nax.yaxis.set_units(inch)\nax.autoscale_view()\n\n#plt.savefig('barchart_demo')\nplt.show()\n",
"# -*- coding: utf-8 -*-\n\nfrom __future__ import (absolute_import, division, print_function,\n unicode_literals)\n\nimport six\nfrom six.moves import map, zip\n\nimport math\n\nimport matplotlib as mpl\nimport numpy as np\nimport matplotlib.cbook as cbook\nimport matplotlib.artist as artist\nfrom matplotlib.artist import allow_rasterization\nimport matplotlib.colors as colors\nfrom matplotlib import docstring\nimport matplotlib.transforms as transforms\nfrom matplotlib.path import Path\nfrom matplotlib.cbook import mplDeprecation\n\n# these are not available for the object inspector until after the\n# class is built so we define an initial set here for the init\n# function and they will be overridden after object definition\ndocstring.interpd.update(Patch=\"\"\"\n\n ================= ==============================================\n Property Description\n ================= ==============================================\n alpha float\n animated [True | False]\n antialiased or aa [True | False]\n capstyle ['butt' | 'round' | 'projecting']\n clip_box a matplotlib.transform.Bbox instance\n clip_on [True | False]\n edgecolor or ec any matplotlib color\n facecolor or fc any matplotlib color\n figure a matplotlib.figure.Figure instance\n fill [True | False]\n hatch unknown\n joinstyle ['miter' | 'round' | 'bevel']\n label any string\n linewidth or lw float\n lod [True | False]\n transform a matplotlib.transform transformation instance\n visible [True | False]\n zorder any number\n ================= ==============================================\n\n \"\"\")\n\n\nclass Patch(artist.Artist):\n \"\"\"\n A patch is a 2D artist with a face color and an edge color.\n\n If any of *edgecolor*, *facecolor*, *linewidth*, or *antialiased*\n are *None*, they default to their rc params setting.\n \"\"\"\n zorder = 1\n validCap = ('butt', 'round', 'projecting')\n validJoin = ('miter', 'round', 'bevel')\n\n def __str__(self):\n return str(self.__class__).split('.')[-1]\n\n def __init__(self,\n edgecolor=None,\n facecolor=None,\n color=None,\n linewidth=None,\n linestyle=None,\n antialiased=None,\n hatch=None,\n fill=True,\n capstyle=None,\n joinstyle=None,\n **kwargs):\n \"\"\"\n The following kwarg properties are supported\n\n %(Patch)s\n \"\"\"\n artist.Artist.__init__(self)\n\n if linewidth is None:\n linewidth = mpl.rcParams['patch.linewidth']\n if linestyle is None:\n linestyle = \"solid\"\n if capstyle is None:\n capstyle = 'butt'\n if joinstyle is None:\n joinstyle = 'miter'\n if antialiased is None:\n antialiased = mpl.rcParams['patch.antialiased']\n\n self._fill = True # needed for set_facecolor call\n if color is not None:\n if (edgecolor is not None or\n facecolor is not None):\n import warnings\n warnings.warn(\"Setting the 'color' property will override\"\n \"the edgecolor or facecolor properties. \")\n self.set_color(color)\n else:\n self.set_edgecolor(edgecolor)\n self.set_facecolor(facecolor)\n self.set_linewidth(linewidth)\n self.set_linestyle(linestyle)\n self.set_antialiased(antialiased)\n self.set_hatch(hatch)\n self.set_fill(fill)\n self.set_capstyle(capstyle)\n self.set_joinstyle(joinstyle)\n self._combined_transform = transforms.IdentityTransform()\n\n if len(kwargs):\n self.update(kwargs)\n\n def get_verts(self):\n \"\"\"\n Return a copy of the vertices used in this patch\n\n If the patch contains Bezier curves, the curves will be\n interpolated by line segments. To access the curves as\n curves, use :meth:`get_path`.\n \"\"\"\n trans = self.get_transform()\n path = self.get_path()\n polygons = path.to_polygons(trans)\n if len(polygons):\n return polygons[0]\n return []\n\n def contains(self, mouseevent, radius=None):\n \"\"\"Test whether the mouse event occurred in the patch.\n\n Returns T/F, {}\n \"\"\"\n # This is a general version of contains that should work on any\n # patch with a path. However, patches that have a faster\n # algebraic solution to hit-testing should override this\n # method.\n if six.callable(self._contains):\n return self._contains(self, mouseevent)\n if radius is None:\n radius = self.get_linewidth()\n inside = self.get_path().contains_point(\n (mouseevent.x, mouseevent.y), self.get_transform(), radius)\n return inside, {}\n\n def contains_point(self, point, radius=None):\n \"\"\"\n Returns *True* if the given point is inside the path\n (transformed with its transform attribute).\n \"\"\"\n if radius is None:\n radius = self.get_linewidth()\n return self.get_path().contains_point(point,\n self.get_transform(),\n radius)\n\n def update_from(self, other):\n \"\"\"\n Updates this :class:`Patch` from the properties of *other*.\n \"\"\"\n artist.Artist.update_from(self, other)\n self.set_edgecolor(other.get_edgecolor())\n self.set_facecolor(other.get_facecolor())\n self.set_fill(other.get_fill())\n self.set_hatch(other.get_hatch())\n self.set_linewidth(other.get_linewidth())\n self.set_linestyle(other.get_linestyle())\n self.set_transform(other.get_data_transform())\n self.set_figure(other.get_figure())\n self.set_alpha(other.get_alpha())\n\n def get_extents(self):\n \"\"\"\n Return a :class:`~matplotlib.transforms.Bbox` object defining\n the axis-aligned extents of the :class:`Patch`.\n \"\"\"\n return self.get_path().get_extents(self.get_transform())\n\n def get_transform(self):\n \"\"\"\n Return the :class:`~matplotlib.transforms.Transform` applied\n to the :class:`Patch`.\n \"\"\"\n return self.get_patch_transform() + artist.Artist.get_transform(self)\n\n def get_data_transform(self):\n \"\"\"\n Return the :class:`~matplotlib.transforms.Transform` instance which\n maps data coordinates to physical coordinates.\n \"\"\"\n return artist.Artist.get_transform(self)\n\n def get_patch_transform(self):\n \"\"\"\n Return the :class:`~matplotlib.transforms.Transform` instance which\n takes patch coordinates to data coordinates.\n\n For example, one may define a patch of a circle which represents a\n radius of 5 by providing coordinates for a unit circle, and a\n transform which scales the coordinates (the patch coordinate) by 5.\n \"\"\"\n return transforms.IdentityTransform()\n\n def get_antialiased(self):\n \"\"\"\n Returns True if the :class:`Patch` is to be drawn with antialiasing.\n \"\"\"\n return self._antialiased\n get_aa = get_antialiased\n\n def get_edgecolor(self):\n \"\"\"\n Return the edge color of the :class:`Patch`.\n \"\"\"\n return self._edgecolor\n get_ec = get_edgecolor\n\n def get_facecolor(self):\n \"\"\"\n Return the face color of the :class:`Patch`.\n \"\"\"\n return self._facecolor\n get_fc = get_facecolor\n\n def get_linewidth(self):\n \"\"\"\n Return the line width in points.\n \"\"\"\n return self._linewidth\n get_lw = get_linewidth\n\n def get_linestyle(self):\n \"\"\"\n Return the linestyle. Will be one of ['solid' | 'dashed' |\n 'dashdot' | 'dotted']\n \"\"\"\n return self._linestyle\n get_ls = get_linestyle\n\n def set_antialiased(self, aa):\n \"\"\"\n Set whether to use antialiased rendering\n\n ACCEPTS: [True | False] or None for default\n \"\"\"\n if aa is None:\n aa = mpl.rcParams['patch.antialiased']\n self._antialiased = aa\n\n def set_aa(self, aa):\n \"\"\"alias for set_antialiased\"\"\"\n return self.set_antialiased(aa)\n\n def set_edgecolor(self, color):\n \"\"\"\n Set the patch edge color\n\n ACCEPTS: mpl color spec, or None for default, or 'none' for no color\n \"\"\"\n if color is None:\n color = mpl.rcParams['patch.edgecolor']\n self._original_edgecolor = color\n self._edgecolor = colors.colorConverter.to_rgba(color, self._alpha)\n\n def set_ec(self, color):\n \"\"\"alias for set_edgecolor\"\"\"\n return self.set_edgecolor(color)\n\n def set_facecolor(self, color):\n \"\"\"\n Set the patch face color\n\n ACCEPTS: mpl color spec, or None for default, or 'none' for no color\n \"\"\"\n if color is None:\n color = mpl.rcParams['patch.facecolor']\n self._original_facecolor = color # save: otherwise changing _fill\n # may lose alpha information\n self._facecolor = colors.colorConverter.to_rgba(color, self._alpha)\n if not self._fill:\n self._facecolor = list(self._facecolor)\n self._facecolor[3] = 0\n\n def set_fc(self, color):\n \"\"\"alias for set_facecolor\"\"\"\n return self.set_facecolor(color)\n\n def set_color(self, c):\n \"\"\"\n Set both the edgecolor and the facecolor.\n\n ACCEPTS: matplotlib color spec\n\n .. seealso::\n\n :meth:`set_facecolor`, :meth:`set_edgecolor`\n For setting the edge or face color individually.\n \"\"\"\n self.set_facecolor(c)\n self.set_edgecolor(c)\n\n def set_alpha(self, alpha):\n \"\"\"\n Set the alpha tranparency of the patch.\n\n ACCEPTS: float or None\n \"\"\"\n if alpha is not None:\n try:\n float(alpha)\n except TypeError:\n raise TypeError('alpha must be a float or None')\n artist.Artist.set_alpha(self, alpha)\n self.set_facecolor(self._original_facecolor) # using self._fill and\n # self._alpha\n self.set_edgecolor(self._original_edgecolor)\n\n def set_linewidth(self, w):\n \"\"\"\n Set the patch linewidth in points\n\n ACCEPTS: float or None for default\n \"\"\"\n if w is None:\n w = mpl.rcParams['patch.linewidth']\n self._linewidth = w\n\n def set_lw(self, lw):\n \"\"\"alias for set_linewidth\"\"\"\n return self.set_linewidth(lw)\n\n def set_linestyle(self, ls):\n \"\"\"\n Set the patch linestyle\n\n ACCEPTS: ['solid' | 'dashed' | 'dashdot' | 'dotted']\n \"\"\"\n if ls is None:\n ls = \"solid\"\n self._linestyle = ls\n\n def set_ls(self, ls):\n \"\"\"alias for set_linestyle\"\"\"\n return self.set_linestyle(ls)\n\n def set_fill(self, b):\n \"\"\"\n Set whether to fill the patch\n\n ACCEPTS: [True | False]\n \"\"\"\n self._fill = bool(b)\n self.set_facecolor(self._original_facecolor)\n\n def get_fill(self):\n 'return whether fill is set'\n return self._fill\n\n # Make fill a property so as to preserve the long-standing\n # but somewhat inconsistent behavior in which fill was an\n # attribute.\n fill = property(get_fill, set_fill)\n\n def set_capstyle(self, s):\n \"\"\"\n Set the patch capstyle\n\n ACCEPTS: ['butt' | 'round' | 'projecting']\n \"\"\"\n s = s.lower()\n if s not in self.validCap:\n raise ValueError('set_capstyle passed \"%s\";\\n' % (s,)\n + 'valid capstyles are %s' % (self.validCap,))\n self._capstyle = s\n\n def get_capstyle(self):\n \"Return the current capstyle\"\n return self._capstyle\n\n def set_joinstyle(self, s):\n \"\"\"\n Set the patch joinstyle\n\n ACCEPTS: ['miter' | 'round' | 'bevel']\n \"\"\"\n s = s.lower()\n if s not in self.validJoin:\n raise ValueError('set_joinstyle passed \"%s\";\\n' % (s,)\n + 'valid joinstyles are %s' % (self.validJoin,))\n self._joinstyle = s\n\n def get_joinstyle(self):\n \"Return the current joinstyle\"\n return self._joinstyle\n\n def set_hatch(self, hatch):\n \"\"\"\n Set the hatching pattern\n\n *hatch* can be one of::\n\n / - diagonal hatching\n \\ - back diagonal\n | - vertical\n - - horizontal\n + - crossed\n x - crossed diagonal\n o - small circle\n O - large circle\n . - dots\n * - stars\n\n Letters can be combined, in which case all the specified\n hatchings are done. If same letter repeats, it increases the\n density of hatching of that pattern.\n\n Hatching is supported in the PostScript, PDF, SVG and Agg\n backends only.\n\n ACCEPTS: ['/' | '\\\\\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*']\n \"\"\"\n self._hatch = hatch\n\n def get_hatch(self):\n 'Return the current hatching pattern'\n return self._hatch\n\n @allow_rasterization\n def draw(self, renderer):\n 'Draw the :class:`Patch` to the given *renderer*.'\n if not self.get_visible():\n return\n\n renderer.open_group('patch', self.get_gid())\n gc = renderer.new_gc()\n\n gc.set_foreground(self._edgecolor, isRGBA=True)\n\n lw = self._linewidth\n if self._edgecolor[3] == 0:\n lw = 0\n gc.set_linewidth(lw)\n gc.set_linestyle(self._linestyle)\n gc.set_capstyle(self._capstyle)\n gc.set_joinstyle(self._joinstyle)\n\n gc.set_antialiased(self._antialiased)\n self._set_gc_clip(gc)\n gc.set_url(self._url)\n gc.set_snap(self.get_snap())\n\n rgbFace = self._facecolor\n if rgbFace[3] == 0:\n rgbFace = None # (some?) renderers expect this as no-fill signal\n\n gc.set_alpha(self._alpha)\n\n if self._hatch:\n gc.set_hatch(self._hatch)\n\n if self.get_sketch_params() is not None:\n gc.set_sketch_params(*self.get_sketch_params())\n\n path = self.get_path()\n transform = self.get_transform()\n tpath = transform.transform_path_non_affine(path)\n affine = transform.get_affine()\n\n if self.get_path_effects():\n from matplotlib.patheffects import PathEffectRenderer\n renderer = PathEffectRenderer(self.get_path_effects(), renderer)\n\n renderer.draw_path(gc, tpath, affine, rgbFace)\n\n gc.restore()\n renderer.close_group('patch')\n\n def get_path(self):\n \"\"\"\n Return the path of this patch\n \"\"\"\n raise NotImplementedError('Derived must override')\n\n def get_window_extent(self, renderer=None):\n return self.get_path().get_extents(self.get_transform())\n\n\npatchdoc = artist.kwdoc(Patch)\nfor k in ('Rectangle', 'Circle', 'RegularPolygon', 'Polygon', 'Wedge', 'Arrow',\n 'FancyArrow', 'YAArrow', 'CirclePolygon', 'Ellipse', 'Arc',\n 'FancyBboxPatch', 'Patch'):\n docstring.interpd.update({k: patchdoc})\n\n# define Patch.__init__ docstring after the class has been added to interpd\ndocstring.dedent_interpd(Patch.__init__)\n\n\nclass Shadow(Patch):\n def __str__(self):\n return \"Shadow(%s)\" % (str(self.patch))\n\n @docstring.dedent_interpd\n def __init__(self, patch, ox, oy, props=None, **kwargs):\n \"\"\"\n Create a shadow of the given *patch* offset by *ox*, *oy*.\n *props*, if not *None*, is a patch property update dictionary.\n If *None*, the shadow will have have the same color as the face,\n but darkened.\n\n kwargs are\n %(Patch)s\n \"\"\"\n Patch.__init__(self)\n self.patch = patch\n self.props = props\n self._ox, self._oy = ox, oy\n self._shadow_transform = transforms.Affine2D()\n self._update()\n\n def _update(self):\n self.update_from(self.patch)\n if self.props is not None:\n self.update(self.props)\n else:\n r, g, b, a = colors.colorConverter.to_rgba(\n self.patch.get_facecolor())\n rho = 0.3\n r = rho * r\n g = rho * g\n b = rho * b\n\n self.set_facecolor((r, g, b, 0.5))\n self.set_edgecolor((r, g, b, 0.5))\n self.set_alpha(0.5)\n\n def _update_transform(self, renderer):\n ox = renderer.points_to_pixels(self._ox)\n oy = renderer.points_to_pixels(self._oy)\n self._shadow_transform.clear().translate(ox, oy)\n\n def _get_ox(self):\n return self._ox\n\n def _set_ox(self, ox):\n self._ox = ox\n\n def _get_oy(self):\n return self._oy\n\n def _set_oy(self, oy):\n self._oy = oy\n\n def get_path(self):\n return self.patch.get_path()\n\n def get_patch_transform(self):\n return self.patch.get_patch_transform() + self._shadow_transform\n\n def draw(self, renderer):\n self._update_transform(renderer)\n Patch.draw(self, renderer)\n\n\nclass Rectangle(Patch):\n \"\"\"\n Draw a rectangle with lower left at *xy* = (*x*, *y*) with\n specified *width* and *height*.\n \"\"\"\n\n def __str__(self):\n return self.__class__.__name__ \\\n + \"(%g,%g;%gx%g)\" % (self._x, self._y, self._width, self._height)\n\n @docstring.dedent_interpd\n def __init__(self, xy, width, height, angle=0.0, **kwargs):\n \"\"\"\n\n *angle*\n rotation in degrees (anti-clockwise)\n\n *fill* is a boolean indicating whether to fill the rectangle\n\n Valid kwargs are:\n %(Patch)s\n \"\"\"\n\n Patch.__init__(self, **kwargs)\n\n self._x = xy[0]\n self._y = xy[1]\n self._width = width\n self._height = height\n self._angle = angle\n # Note: This cannot be calculated until this is added to an Axes\n self._rect_transform = transforms.IdentityTransform()\n\n def get_path(self):\n \"\"\"\n Return the vertices of the rectangle\n \"\"\"\n return Path.unit_rectangle()\n\n def _update_patch_transform(self):\n \"\"\"NOTE: This cannot be called until after this has been added\n to an Axes, otherwise unit conversion will fail. This\n maxes it very important to call the accessor method and\n not directly access the transformation member variable.\n \"\"\"\n x = self.convert_xunits(self._x)\n y = self.convert_yunits(self._y)\n width = self.convert_xunits(self._width)\n height = self.convert_yunits(self._height)\n bbox = transforms.Bbox.from_bounds(x, y, width, height)\n rot_trans = transforms.Affine2D()\n rot_trans.rotate_deg_around(x, y, self._angle)\n self._rect_transform = transforms.BboxTransformTo(bbox)\n self._rect_transform += rot_trans\n\n def get_patch_transform(self):\n self._update_patch_transform()\n return self._rect_transform\n\n def contains(self, mouseevent):\n # special case the degenerate rectangle\n if self._width == 0 or self._height == 0:\n return False, {}\n\n x, y = self.get_transform().inverted().transform_point(\n (mouseevent.x, mouseevent.y))\n return (x >= 0.0 and x <= 1.0 and y >= 0.0 and y <= 1.0), {}\n\n def get_x(self):\n \"Return the left coord of the rectangle\"\n return self._x\n\n def get_y(self):\n \"Return the bottom coord of the rectangle\"\n return self._y\n\n def get_xy(self):\n \"Return the left and bottom coords of the rectangle\"\n return self._x, self._y\n\n def get_width(self):\n \"Return the width of the rectangle\"\n return self._width\n\n def get_height(self):\n \"Return the height of the rectangle\"\n return self._height\n\n def set_x(self, x):\n \"\"\"\n Set the left coord of the rectangle\n\n ACCEPTS: float\n \"\"\"\n self._x = x\n\n def set_y(self, y):\n \"\"\"\n Set the bottom coord of the rectangle\n\n ACCEPTS: float\n \"\"\"\n self._y = y\n\n def set_xy(self, xy):\n \"\"\"\n Set the left and bottom coords of the rectangle\n\n ACCEPTS: 2-item sequence\n \"\"\"\n self._x, self._y = xy\n\n def set_width(self, w):\n \"\"\"\n Set the width rectangle\n\n ACCEPTS: float\n \"\"\"\n self._width = w\n\n def set_height(self, h):\n \"\"\"\n Set the width rectangle\n\n ACCEPTS: float\n \"\"\"\n self._height = h\n\n def set_bounds(self, *args):\n \"\"\"\n Set the bounds of the rectangle: l,b,w,h\n\n ACCEPTS: (left, bottom, width, height)\n \"\"\"\n if len(args) == 0:\n l, b, w, h = args[0]\n else:\n l, b, w, h = args\n self._x = l\n self._y = b\n self._width = w\n self._height = h\n\n def get_bbox(self):\n return transforms.Bbox.from_bounds(self._x, self._y,\n self._width, self._height)\n\n xy = property(get_xy, set_xy)\n\n\nclass RegularPolygon(Patch):\n \"\"\"\n A regular polygon patch.\n \"\"\"\n def __str__(self):\n return \"Poly%d(%g,%g)\" % (self._numVertices, self._xy[0], self._xy[1])\n\n @docstring.dedent_interpd\n def __init__(self, xy, numVertices, radius=5, orientation=0,\n **kwargs):\n \"\"\"\n Constructor arguments:\n\n *xy*\n A length 2 tuple (*x*, *y*) of the center.\n\n *numVertices*\n the number of vertices.\n\n *radius*\n The distance from the center to each of the vertices.\n\n *orientation*\n rotates the polygon (in radians).\n\n Valid kwargs are:\n %(Patch)s\n \"\"\"\n self._xy = xy\n self._numVertices = numVertices\n self._orientation = orientation\n self._radius = radius\n self._path = Path.unit_regular_polygon(numVertices)\n self._poly_transform = transforms.Affine2D()\n self._update_transform()\n\n Patch.__init__(self, **kwargs)\n\n def _update_transform(self):\n self._poly_transform.clear() \\\n .scale(self.radius) \\\n .rotate(self.orientation) \\\n .translate(*self.xy)\n\n def _get_xy(self):\n return self._xy\n\n def _set_xy(self, xy):\n self._xy = xy\n self._update_transform()\n xy = property(_get_xy, _set_xy)\n\n def _get_orientation(self):\n return self._orientation\n\n def _set_orientation(self, orientation):\n self._orientation = orientation\n self._update_transform()\n orientation = property(_get_orientation, _set_orientation)\n\n def _get_radius(self):\n return self._radius\n\n def _set_radius(self, radius):\n self._radius = radius\n self._update_transform()\n radius = property(_get_radius, _set_radius)\n\n def _get_numvertices(self):\n return self._numVertices\n\n def _set_numvertices(self, numVertices):\n self._numVertices = numVertices\n\n numvertices = property(_get_numvertices, _set_numvertices)\n\n def get_path(self):\n return self._path\n\n def get_patch_transform(self):\n self._update_transform()\n return self._poly_transform\n\n\nclass PathPatch(Patch):\n \"\"\"\n A general polycurve path patch.\n \"\"\"\n def __str__(self):\n return \"Poly((%g, %g) ...)\" % tuple(self._path.vertices[0])\n\n @docstring.dedent_interpd\n def __init__(self, path, **kwargs):\n \"\"\"\n *path* is a :class:`matplotlib.path.Path` object.\n\n Valid kwargs are:\n %(Patch)s\n\n .. seealso::\n\n :class:`Patch`\n For additional kwargs\n\n \"\"\"\n Patch.__init__(self, **kwargs)\n self._path = path\n\n def get_path(self):\n return self._path\n\n\nclass Polygon(Patch):\n \"\"\"\n A general polygon patch.\n \"\"\"\n def __str__(self):\n return \"Poly((%g, %g) ...)\" % tuple(self._path.vertices[0])\n\n @docstring.dedent_interpd\n def __init__(self, xy, closed=True, **kwargs):\n \"\"\"\n *xy* is a numpy array with shape Nx2.\n\n If *closed* is *True*, the polygon will be closed so the\n starting and ending points are the same.\n\n Valid kwargs are:\n %(Patch)s\n\n .. seealso::\n\n :class:`Patch`\n For additional kwargs\n\n \"\"\"\n Patch.__init__(self, **kwargs)\n self._closed = closed\n self.set_xy(xy)\n\n def get_path(self):\n return self._path\n\n def get_closed(self):\n return self._closed\n\n def set_closed(self, closed):\n if self._closed == bool(closed):\n return\n self._closed = bool(closed)\n self.set_xy(self.get_xy())\n\n def get_xy(self):\n return self._path.vertices\n\n def set_xy(self, xy):\n xy = np.asarray(xy)\n if self._closed:\n if len(xy) and (xy[0] != xy[-1]).any():\n xy = np.concatenate([xy, [xy[0]]])\n else:\n if len(xy) > 2 and (xy[0] == xy[-1]).all():\n xy = xy[:-1]\n self._path = Path(xy, closed=self._closed)\n\n _get_xy = get_xy\n _set_xy = set_xy\n xy = property(\n get_xy, set_xy, None,\n \"\"\"Set/get the vertices of the polygon. This property is\n provided for backward compatibility with matplotlib 0.91.x\n only. New code should use\n :meth:`~matplotlib.patches.Polygon.get_xy` and\n :meth:`~matplotlib.patches.Polygon.set_xy` instead.\"\"\")\n\n\nclass Wedge(Patch):\n \"\"\"\n Wedge shaped patch.\n \"\"\"\n def __str__(self):\n return \"Wedge(%g,%g)\" % (self.theta1, self.theta2)\n\n @docstring.dedent_interpd\n def __init__(self, center, r, theta1, theta2, width=None, **kwargs):\n \"\"\"\n Draw a wedge centered at *x*, *y* center with radius *r* that\n sweeps *theta1* to *theta2* (in degrees). If *width* is given,\n then a partial wedge is drawn from inner radius *r* - *width*\n to outer radius *r*.\n\n Valid kwargs are:\n\n %(Patch)s\n \"\"\"\n Patch.__init__(self, **kwargs)\n self.center = center\n self.r, self.width = r, width\n self.theta1, self.theta2 = theta1, theta2\n self._patch_transform = transforms.IdentityTransform()\n self._recompute_path()\n\n def _recompute_path(self):\n # Inner and outer rings are connected unless the annulus is complete\n if abs((self.theta2 - self.theta1) - 360) <= 1e-12:\n theta1, theta2 = 0, 360\n connector = Path.MOVETO\n else:\n theta1, theta2 = self.theta1, self.theta2\n connector = Path.LINETO\n\n # Form the outer ring\n arc = Path.arc(theta1, theta2)\n\n if self.width is not None:\n # Partial annulus needs to draw the outer ring\n # followed by a reversed and scaled inner ring\n v1 = arc.vertices\n v2 = arc.vertices[::-1] * float(self.r - self.width) / self.r\n v = np.vstack([v1, v2, v1[0, :], (0, 0)])\n c = np.hstack([arc.codes, arc.codes, connector, Path.CLOSEPOLY])\n c[len(arc.codes)] = connector\n else:\n # Wedge doesn't need an inner ring\n v = np.vstack([arc.vertices, [(0, 0), arc.vertices[0, :], (0, 0)]])\n c = np.hstack([arc.codes, [connector, connector, Path.CLOSEPOLY]])\n\n # Shift and scale the wedge to the final location.\n v *= self.r\n v += np.asarray(self.center)\n self._path = Path(v, c)\n\n def set_center(self, center):\n self._path = None\n self.center = center\n\n def set_radius(self, radius):\n self._path = None\n self.radius = radius\n\n def set_theta1(self, theta1):\n self._path = None\n self.theta1 = theta1\n\n def set_theta2(self, theta2):\n self._path = None\n self.theta2 = theta2\n\n def set_width(self, width):\n self._path = None\n self.width = width\n\n def get_path(self):\n if self._path is None:\n self._recompute_path()\n return self._path\n\n\n# COVERAGE NOTE: Not used internally or from examples\nclass Arrow(Patch):\n \"\"\"\n An arrow patch.\n \"\"\"\n def __str__(self):\n return \"Arrow()\"\n\n _path = Path([\n [0.0, 0.1], [0.0, -0.1],\n [0.8, -0.1], [0.8, -0.3],\n [1.0, 0.0], [0.8, 0.3],\n [0.8, 0.1], [0.0, 0.1]],\n closed=True)\n\n @docstring.dedent_interpd\n def __init__(self, x, y, dx, dy, width=1.0, **kwargs):\n \"\"\"\n Draws an arrow, starting at (*x*, *y*), direction and length\n given by (*dx*, *dy*) the width of the arrow is scaled by *width*.\n\n Valid kwargs are:\n %(Patch)s\n \"\"\"\n Patch.__init__(self, **kwargs)\n L = np.sqrt(dx ** 2 + dy ** 2) or 1 # account for div by zero\n cx = float(dx) / L\n sx = float(dy) / L\n\n trans1 = transforms.Affine2D().scale(L, width)\n trans2 = transforms.Affine2D.from_values(cx, sx, -sx, cx, 0.0, 0.0)\n trans3 = transforms.Affine2D().translate(x, y)\n trans = trans1 + trans2 + trans3\n self._patch_transform = trans.frozen()\n\n def get_path(self):\n return self._path\n\n def get_patch_transform(self):\n return self._patch_transform\n\n\nclass FancyArrow(Polygon):\n \"\"\"\n Like Arrow, but lets you set head width and head height independently.\n \"\"\"\n\n def __str__(self):\n return \"FancyArrow()\"\n\n @docstring.dedent_interpd\n def __init__(self, x, y, dx, dy, width=0.001, length_includes_head=False,\n head_width=None, head_length=None, shape='full', overhang=0,\n head_starts_at_zero=False, **kwargs):\n \"\"\"\n Constructor arguments\n *width*: float (default: 0.001)\n width of full arrow tail\n\n *length_includes_head*: [True | False] (default: False)\n True if head is to be counted in calculating the length.\n\n *head_width*: float or None (default: 3*width)\n total width of the full arrow head\n\n *head_length*: float or None (default: 1.5 * head_width)\n length of arrow head\n\n *shape*: ['full', 'left', 'right'] (default: 'full')\n draw the left-half, right-half, or full arrow\n\n *overhang*: float (default: 0)\n fraction that the arrow is swept back (0 overhang means\n triangular shape). Can be negative or greater than one.\n\n *head_starts_at_zero*: [True | False] (default: False)\n if True, the head starts being drawn at coordinate 0\n instead of ending at coordinate 0.\n\n Other valid kwargs (inherited from :class:`Patch`) are:\n %(Patch)s\n\n \"\"\"\n if head_width is None:\n head_width = 20 * width\n if head_length is None:\n head_length = 1.5 * head_width\n\n distance = np.sqrt(dx ** 2 + dy ** 2)\n if length_includes_head:\n length = distance\n else:\n length = distance + head_length\n if not length:\n verts = [] # display nothing if empty\n else:\n # start by drawing horizontal arrow, point at (0,0)\n hw, hl, hs, lw = head_width, head_length, overhang, width\n left_half_arrow = np.array([\n [0.0, 0.0], # tip\n [-hl, -hw / 2.0], # leftmost\n [-hl * (1 - hs), -lw / 2.0], # meets stem\n [-length, -lw / 2.0], # bottom left\n [-length, 0],\n ])\n #if we're not including the head, shift up by head length\n if not length_includes_head:\n left_half_arrow += [head_length, 0]\n #if the head starts at 0, shift up by another head length\n if head_starts_at_zero:\n left_half_arrow += [head_length / 2.0, 0]\n #figure out the shape, and complete accordingly\n if shape == 'left':\n coords = left_half_arrow\n else:\n right_half_arrow = left_half_arrow * [1, -1]\n if shape == 'right':\n coords = right_half_arrow\n elif shape == 'full':\n # The half-arrows contain the midpoint of the stem,\n # which we can omit from the full arrow. Including it\n # twice caused a problem with xpdf.\n coords = np.concatenate([left_half_arrow[:-1],\n right_half_arrow[-2::-1]])\n else:\n raise ValueError(\"Got unknown shape: %s\" % shape)\n cx = float(dx) / distance\n sx = float(dy) / distance\n M = np.array([[cx, sx], [-sx, cx]])\n verts = np.dot(coords, M) + (x + dx, y + dy)\n\n Polygon.__init__(self, list(map(tuple, verts)), closed=True, **kwargs)\n\n\ndocstring.interpd.update({\"FancyArrow\": FancyArrow.__init__.__doc__})\n\ndocstring.interpd.update({\"FancyArrow\": FancyArrow.__init__.__doc__})\n\n\nclass YAArrow(Patch):\n \"\"\"\n Yet another arrow class.\n\n This is an arrow that is defined in display space and has a tip at\n *x1*, *y1* and a base at *x2*, *y2*.\n \"\"\"\n def __str__(self):\n return \"YAArrow()\"\n\n @docstring.dedent_interpd\n def __init__(self, figure, xytip, xybase,\n width=4, frac=0.1, headwidth=12, **kwargs):\n \"\"\"\n Constructor arguments:\n\n *xytip*\n (*x*, *y*) location of arrow tip\n\n *xybase*\n (*x*, *y*) location the arrow base mid point\n\n *figure*\n The :class:`~matplotlib.figure.Figure` instance\n (fig.dpi)\n\n *width*\n The width of the arrow in points\n\n *frac*\n The fraction of the arrow length occupied by the head\n\n *headwidth*\n The width of the base of the arrow head in points\n\n Valid kwargs are:\n %(Patch)s\n\n \"\"\"\n self.xytip = xytip\n self.xybase = xybase\n self.width = width\n self.frac = frac\n self.headwidth = headwidth\n Patch.__init__(self, **kwargs)\n # Set self.figure after Patch.__init__, since it sets self.figure to\n # None\n self.figure = figure\n\n def get_path(self):\n # Since this is dpi dependent, we need to recompute the path\n # every time.\n\n # the base vertices\n x1, y1 = self.xytip\n x2, y2 = self.xybase\n k1 = self.width * self.figure.dpi / 72. / 2.\n k2 = self.headwidth * self.figure.dpi / 72. / 2.\n xb1, yb1, xb2, yb2 = self.getpoints(x1, y1, x2, y2, k1)\n\n # a point on the segment 20% of the distance from the tip to the base\n theta = math.atan2(y2 - y1, x2 - x1)\n r = math.sqrt((y2 - y1) ** 2. + (x2 - x1) ** 2.)\n xm = x1 + self.frac * r * math.cos(theta)\n ym = y1 + self.frac * r * math.sin(theta)\n xc1, yc1, xc2, yc2 = self.getpoints(x1, y1, xm, ym, k1)\n xd1, yd1, xd2, yd2 = self.getpoints(x1, y1, xm, ym, k2)\n\n xs = self.convert_xunits([xb1, xb2, xc2, xd2, x1, xd1, xc1, xb1])\n ys = self.convert_yunits([yb1, yb2, yc2, yd2, y1, yd1, yc1, yb1])\n\n return Path(list(zip(xs, ys)), closed=True)\n\n def get_patch_transform(self):\n return transforms.IdentityTransform()\n\n def getpoints(self, x1, y1, x2, y2, k):\n \"\"\"\n For line segment defined by (*x1*, *y1*) and (*x2*, *y2*)\n return the points on the line that is perpendicular to the\n line and intersects (*x2*, *y2*) and the distance from (*x2*,\n *y2*) of the returned points is *k*.\n \"\"\"\n x1, y1, x2, y2, k = list(map(float, (x1, y1, x2, y2, k)))\n\n if y2 - y1 == 0:\n return x2, y2 + k, x2, y2 - k\n elif x2 - x1 == 0:\n return x2 + k, y2, x2 - k, y2\n\n m = (y2 - y1) / (x2 - x1)\n pm = -1. / m\n a = 1\n b = -2 * y2\n c = y2 ** 2. - k ** 2. * pm ** 2. / (1. + pm ** 2.)\n\n y3a = (-b + math.sqrt(b ** 2. - 4 * a * c)) / (2. * a)\n x3a = (y3a - y2) / pm + x2\n\n y3b = (-b - math.sqrt(b ** 2. - 4 * a * c)) / (2. * a)\n x3b = (y3b - y2) / pm + x2\n return x3a, y3a, x3b, y3b\n\n\nclass CirclePolygon(RegularPolygon):\n \"\"\"\n A polygon-approximation of a circle patch.\n \"\"\"\n def __str__(self):\n return \"CirclePolygon(%d,%d)\" % self.center\n\n @docstring.dedent_interpd\n def __init__(self, xy, radius=5,\n resolution=20, # the number of vertices\n ** kwargs):\n \"\"\"\n Create a circle at *xy* = (*x*, *y*) with given *radius*.\n This circle is approximated by a regular polygon with\n *resolution* sides. For a smoother circle drawn with splines,\n see :class:`~matplotlib.patches.Circle`.\n\n Valid kwargs are:\n %(Patch)s\n\n \"\"\"\n RegularPolygon.__init__(self, xy,\n resolution,\n radius,\n orientation=0,\n **kwargs)\n\n\nclass Ellipse(Patch):\n \"\"\"\n A scale-free ellipse.\n \"\"\"\n def __str__(self):\n return \"Ellipse(%s,%s;%sx%s)\" % (self.center[0], self.center[1],\n self.width, self.height)\n\n @docstring.dedent_interpd\n def __init__(self, xy, width, height, angle=0.0, **kwargs):\n \"\"\"\n *xy*\n center of ellipse\n\n *width*\n total length (diameter) of horizontal axis\n\n *height*\n total length (diameter) of vertical axis\n\n *angle*\n rotation in degrees (anti-clockwise)\n\n Valid kwargs are:\n %(Patch)s\n \"\"\"\n Patch.__init__(self, **kwargs)\n\n self.center = xy\n self.width, self.height = width, height\n self.angle = angle\n self._path = Path.unit_circle()\n # Note: This cannot be calculated until this is added to an Axes\n self._patch_transform = transforms.IdentityTransform()\n\n def _recompute_transform(self):\n \"\"\"NOTE: This cannot be called until after this has been added\n to an Axes, otherwise unit conversion will fail. This\n maxes it very important to call the accessor method and\n not directly access the transformation member variable.\n \"\"\"\n center = (self.convert_xunits(self.center[0]),\n self.convert_yunits(self.center[1]))\n width = self.convert_xunits(self.width)\n height = self.convert_yunits(self.height)\n self._patch_transform = transforms.Affine2D() \\\n .scale(width * 0.5, height * 0.5) \\\n .rotate_deg(self.angle) \\\n .translate(*center)\n\n def get_path(self):\n \"\"\"\n Return the vertices of the rectangle\n \"\"\"\n return self._path\n\n def get_patch_transform(self):\n self._recompute_transform()\n return self._patch_transform\n\n def contains(self, ev):\n if ev.x is None or ev.y is None:\n return False, {}\n x, y = self.get_transform().inverted().transform_point((ev.x, ev.y))\n return (x * x + y * y) <= 1.0, {}\n\n\nclass Circle(Ellipse):\n \"\"\"\n A circle patch.\n \"\"\"\n def __str__(self):\n return \"Circle((%g,%g),r=%g)\" % (self.center[0],\n self.center[1],\n self.radius)\n\n @docstring.dedent_interpd\n def __init__(self, xy, radius=5, **kwargs):\n \"\"\"\n Create true circle at center *xy* = (*x*, *y*) with given\n *radius*. Unlike :class:`~matplotlib.patches.CirclePolygon`\n which is a polygonal approximation, this uses Bézier splines\n and is much closer to a scale-free circle.\n\n Valid kwargs are:\n %(Patch)s\n\n \"\"\"\n self.radius = radius\n Ellipse.__init__(self, xy, radius * 2, radius * 2, **kwargs)\n\n def set_radius(self, radius):\n \"\"\"\n Set the radius of the circle\n\n ACCEPTS: float\n \"\"\"\n self.width = self.height = 2 * radius\n\n def get_radius(self):\n 'return the radius of the circle'\n return self.width / 2.\n\n radius = property(get_radius, set_radius)\n\n\nclass Arc(Ellipse):\n \"\"\"\n An elliptical arc. Because it performs various optimizations, it\n can not be filled.\n\n The arc must be used in an :class:`~matplotlib.axes.Axes`\n instance---it can not be added directly to a\n :class:`~matplotlib.figure.Figure`---because it is optimized to\n only render the segments that are inside the axes bounding box\n with high resolution.\n \"\"\"\n def __str__(self):\n return \"Arc(%s,%s;%sx%s)\" % (self.center[0], self.center[1],\n self.width, self.height)\n\n @docstring.dedent_interpd\n def __init__(self, xy, width, height, angle=0.0,\n theta1=0.0, theta2=360.0, **kwargs):\n \"\"\"\n The following args are supported:\n\n *xy*\n center of ellipse\n\n *width*\n length of horizontal axis\n\n *height*\n length of vertical axis\n\n *angle*\n rotation in degrees (anti-clockwise)\n\n *theta1*\n starting angle of the arc in degrees\n\n *theta2*\n ending angle of the arc in degrees\n\n If *theta1* and *theta2* are not provided, the arc will form a\n complete ellipse.\n\n Valid kwargs are:\n\n %(Patch)s\n \"\"\"\n fill = kwargs.setdefault('fill', False)\n if fill:\n raise ValueError(\"Arc objects can not be filled\")\n\n Ellipse.__init__(self, xy, width, height, angle, **kwargs)\n\n self.theta1 = theta1\n self.theta2 = theta2\n\n self._path = Path.arc(self.theta1, self.theta2)\n\n @allow_rasterization\n def draw(self, renderer):\n \"\"\"\n Ellipses are normally drawn using an approximation that uses\n eight cubic bezier splines. The error of this approximation\n is 1.89818e-6, according to this unverified source:\n\n Lancaster, Don. Approximating a Circle or an Ellipse Using\n Four Bezier Cubic Splines.\n\n http://www.tinaja.com/glib/ellipse4.pdf\n\n There is a use case where very large ellipses must be drawn\n with very high accuracy, and it is too expensive to render the\n entire ellipse with enough segments (either splines or line\n segments). Therefore, in the case where either radius of the\n ellipse is large enough that the error of the spline\n approximation will be visible (greater than one pixel offset\n from the ideal), a different technique is used.\n\n In that case, only the visible parts of the ellipse are drawn,\n with each visible arc using a fixed number of spline segments\n (8). The algorithm proceeds as follows:\n\n 1. The points where the ellipse intersects the axes bounding\n box are located. (This is done be performing an inverse\n transformation on the axes bbox such that it is relative\n to the unit circle -- this makes the intersection\n calculation much easier than doing rotated ellipse\n intersection directly).\n\n This uses the \"line intersecting a circle\" algorithm\n from:\n\n Vince, John. Geometry for Computer Graphics: Formulae,\n Examples & Proofs. London: Springer-Verlag, 2005.\n\n 2. The angles of each of the intersection points are\n calculated.\n\n 3. Proceeding counterclockwise starting in the positive\n x-direction, each of the visible arc-segments between the\n pairs of vertices are drawn using the bezier arc\n approximation technique implemented in\n :meth:`matplotlib.path.Path.arc`.\n \"\"\"\n if not hasattr(self, 'axes'):\n raise RuntimeError('Arcs can only be used in Axes instances')\n\n self._recompute_transform()\n\n # Get the width and height in pixels\n width = self.convert_xunits(self.width)\n height = self.convert_yunits(self.height)\n width, height = self.get_transform().transform_point(\n (width, height))\n inv_error = (1.0 / 1.89818e-6) * 0.5\n\n if width < inv_error and height < inv_error:\n #self._path = Path.arc(self.theta1, self.theta2)\n return Patch.draw(self, renderer)\n\n def iter_circle_intersect_on_line(x0, y0, x1, y1):\n dx = x1 - x0\n dy = y1 - y0\n dr2 = dx * dx + dy * dy\n D = x0 * y1 - x1 * y0\n D2 = D * D\n discrim = dr2 - D2\n\n # Single (tangential) intersection\n if discrim == 0.0:\n x = (D * dy) / dr2\n y = (-D * dx) / dr2\n yield x, y\n elif discrim > 0.0:\n # The definition of \"sign\" here is different from\n # np.sign: we never want to get 0.0\n if dy < 0.0:\n sign_dy = -1.0\n else:\n sign_dy = 1.0\n sqrt_discrim = np.sqrt(discrim)\n for sign in (1., -1.):\n x = (D * dy + sign * sign_dy * dx * sqrt_discrim) / dr2\n y = (-D * dx + sign * np.abs(dy) * sqrt_discrim) / dr2\n yield x, y\n\n def iter_circle_intersect_on_line_seg(x0, y0, x1, y1):\n epsilon = 1e-9\n if x1 < x0:\n x0e, x1e = x1, x0\n else:\n x0e, x1e = x0, x1\n if y1 < y0:\n y0e, y1e = y1, y0\n else:\n y0e, y1e = y0, y1\n x0e -= epsilon\n y0e -= epsilon\n x1e += epsilon\n y1e += epsilon\n for x, y in iter_circle_intersect_on_line(x0, y0, x1, y1):\n if x >= x0e and x <= x1e and y >= y0e and y <= y1e:\n yield x, y\n\n # Transforms the axes box_path so that it is relative to the unit\n # circle in the same way that it is relative to the desired\n # ellipse.\n box_path = Path.unit_rectangle()\n box_path_transform = transforms.BboxTransformTo(self.axes.bbox) + \\\n self.get_transform().inverted()\n box_path = box_path.transformed(box_path_transform)\n\n PI = np.pi\n TWOPI = PI * 2.0\n RAD2DEG = 180.0 / PI\n DEG2RAD = PI / 180.0\n theta1 = self.theta1\n theta2 = self.theta2\n thetas = {}\n # For each of the point pairs, there is a line segment\n for p0, p1 in zip(box_path.vertices[:-1], box_path.vertices[1:]):\n x0, y0 = p0\n x1, y1 = p1\n for x, y in iter_circle_intersect_on_line_seg(x0, y0, x1, y1):\n theta = np.arccos(x)\n if y < 0:\n theta = TWOPI - theta\n # Convert radians to angles\n theta *= RAD2DEG\n if theta > theta1 and theta < theta2:\n thetas[theta] = None\n\n thetas = list(six.iterkeys(thetas))\n thetas.sort()\n thetas.append(theta2)\n\n last_theta = theta1\n theta1_rad = theta1 * DEG2RAD\n inside = box_path.contains_point((np.cos(theta1_rad),\n np.sin(theta1_rad)))\n\n # save original path\n path_original = self._path\n for theta in thetas:\n if inside:\n Path.arc(last_theta, theta, 8)\n Patch.draw(self, renderer)\n inside = False\n else:\n inside = True\n last_theta = theta\n\n # restore original path\n self._path = path_original\n\n\ndef bbox_artist(artist, renderer, props=None, fill=True):\n \"\"\"\n This is a debug function to draw a rectangle around the bounding\n box returned by\n :meth:`~matplotlib.artist.Artist.get_window_extent` of an artist,\n to test whether the artist is returning the correct bbox.\n\n *props* is a dict of rectangle props with the additional property\n 'pad' that sets the padding around the bbox in points.\n \"\"\"\n if props is None:\n props = {}\n props = props.copy() # don't want to alter the pad externally\n pad = props.pop('pad', 4)\n pad = renderer.points_to_pixels(pad)\n bbox = artist.get_window_extent(renderer)\n l, b, w, h = bbox.bounds\n l -= pad / 2.\n b -= pad / 2.\n w += pad\n h += pad\n r = Rectangle(xy=(l, b),\n width=w,\n height=h,\n fill=fill,\n )\n r.set_transform(transforms.IdentityTransform())\n r.set_clip_on(False)\n r.update(props)\n r.draw(renderer)\n\n\ndef draw_bbox(bbox, renderer, color='k', trans=None):\n \"\"\"\n This is a debug function to draw a rectangle around the bounding\n box returned by\n :meth:`~matplotlib.artist.Artist.get_window_extent` of an artist,\n to test whether the artist is returning the correct bbox.\n \"\"\"\n\n l, b, w, h = bbox.bounds\n r = Rectangle(xy=(l, b),\n width=w,\n height=h,\n edgecolor=color,\n fill=False,\n )\n if trans is not None:\n r.set_transform(trans)\n r.set_clip_on(False)\n r.draw(renderer)\n\n\ndef _pprint_table(_table, leadingspace=2):\n \"\"\"\n Given the list of list of strings, return a string of REST table format.\n \"\"\"\n if leadingspace:\n pad = ' ' * leadingspace\n else:\n pad = ''\n\n columns = [[] for cell in _table[0]]\n\n for row in _table:\n for column, cell in zip(columns, row):\n column.append(cell)\n\n col_len = [max([len(cell) for cell in column]) for column in columns]\n\n lines = []\n table_formatstr = pad + ' '.join([('=' * cl) for cl in col_len])\n\n lines.append('')\n lines.append(table_formatstr)\n lines.append(pad + ' '.join([cell.ljust(cl)\n for cell, cl\n in zip(_table[0], col_len)]))\n lines.append(table_formatstr)\n\n lines.extend([(pad + ' '.join([cell.ljust(cl)\n for cell, cl\n in zip(row, col_len)]))\n for row in _table[1:]])\n\n lines.append(table_formatstr)\n lines.append('')\n return \"\\n\".join(lines)\n\n\ndef _pprint_styles(_styles):\n \"\"\"\n A helper function for the _Style class. Given the dictionary of\n (stylename : styleclass), return a formatted string listing all the\n styles. Used to update the documentation.\n \"\"\"\n names, attrss, clss = [], [], []\n\n import inspect\n\n _table = [[\"Class\", \"Name\", \"Attrs\"]]\n\n for name, cls in sorted(_styles.items()):\n args, varargs, varkw, defaults = inspect.getargspec(cls.__init__)\n if defaults:\n args = [(argname, argdefault)\n for argname, argdefault in zip(args[1:], defaults)]\n else:\n args = None\n\n if args is None:\n argstr = 'None'\n else:\n argstr = \",\".join([(\"%s=%s\" % (an, av))\n for an, av\n in args])\n\n #adding ``quotes`` since - and | have special meaning in reST\n _table.append([cls.__name__, \"``%s``\" % name, argstr])\n\n return _pprint_table(_table)\n\n\nclass _Style(object):\n \"\"\"\n A base class for the Styles. It is meant to be a container class,\n where actual styles are declared as subclass of it, and it\n provides some helper functions.\n \"\"\"\n def __new__(self, stylename, **kw):\n \"\"\"\n return the instance of the subclass with the given style name.\n \"\"\"\n\n # the \"class\" should have the _style_list attribute, which is\n # a dictionary of stylname, style class paie.\n\n _list = stylename.replace(\" \", \"\").split(\",\")\n _name = _list[0].lower()\n try:\n _cls = self._style_list[_name]\n except KeyError:\n raise ValueError(\"Unknown style : %s\" % stylename)\n\n try:\n _args_pair = [cs.split(\"=\") for cs in _list[1:]]\n _args = dict([(k, float(v)) for k, v in _args_pair])\n except ValueError:\n raise ValueError(\"Incorrect style argument : %s\" % stylename)\n _args.update(kw)\n\n return _cls(**_args)\n\n @classmethod\n def get_styles(klass):\n \"\"\"\n A class method which returns a dictionary of available styles.\n \"\"\"\n return klass._style_list\n\n @classmethod\n def pprint_styles(klass):\n \"\"\"\n A class method which returns a string of the available styles.\n \"\"\"\n return _pprint_styles(klass._style_list)\n\n @classmethod\n def register(klass, name, style):\n \"\"\"\n Register a new style.\n \"\"\"\n\n if not issubclass(style, klass._Base):\n raise ValueError(\"%s must be a subclass of %s\" % (style,\n klass._Base))\n klass._style_list[name] = style\n\n\nclass BoxStyle(_Style):\n \"\"\"\n :class:`BoxStyle` is a container class which defines several\n boxstyle classes, which are used for :class:`FancyBoxPatch`.\n\n A style object can be created as::\n\n BoxStyle.Round(pad=0.2)\n\n or::\n\n BoxStyle(\"Round\", pad=0.2)\n\n or::\n\n BoxStyle(\"Round, pad=0.2\")\n\n Following boxstyle classes are defined.\n\n %(AvailableBoxstyles)s\n\n An instance of any boxstyle class is an callable object,\n whose call signature is::\n\n __call__(self, x0, y0, width, height, mutation_size, aspect_ratio=1.)\n\n and returns a :class:`Path` instance. *x0*, *y0*, *width* and\n *height* specify the location and size of the box to be\n drawn. *mutation_scale* determines the overall size of the\n mutation (by which I mean the transformation of the rectangle to\n the fancy box). *mutation_aspect* determines the aspect-ratio of\n the mutation.\n\n .. plot:: mpl_examples/pylab_examples/fancybox_demo2.py\n \"\"\"\n\n _style_list = {}\n\n class _Base(object):\n \"\"\"\n :class:`BBoxTransmuterBase` and its derivatives are used to make a\n fancy box around a given rectangle. The :meth:`__call__` method\n returns the :class:`~matplotlib.path.Path` of the fancy box. This\n class is not an artist and actual drawing of the fancy box is done\n by the :class:`FancyBboxPatch` class.\n \"\"\"\n\n # The derived classes are required to be able to be initialized\n # w/o arguments, i.e., all its argument (except self) must have\n # the default values.\n\n def __init__(self):\n \"\"\"\n initializtion.\n \"\"\"\n super(BoxStyle._Base, self).__init__()\n\n def transmute(self, x0, y0, width, height, mutation_size):\n \"\"\"\n The transmute method is a very core of the\n :class:`BboxTransmuter` class and must be overriden in the\n subclasses. It receives the location and size of the\n rectangle, and the mutation_size, with which the amount of\n padding and etc. will be scaled. It returns a\n :class:`~matplotlib.path.Path` instance.\n \"\"\"\n raise NotImplementedError('Derived must override')\n\n def __call__(self, x0, y0, width, height, mutation_size,\n aspect_ratio=1.):\n \"\"\"\n Given the location and size of the box, return the path of\n the box around it.\n\n - *x0*, *y0*, *width*, *height* : location and size of the box\n - *mutation_size* : a reference scale for the mutation.\n - *aspect_ratio* : aspect-ration for the mutation.\n \"\"\"\n # The __call__ method is a thin wrapper around the transmute method\n # and take care of the aspect.\n\n if aspect_ratio is not None:\n # Squeeze the given height by the aspect_ratio\n y0, height = y0 / aspect_ratio, height / aspect_ratio\n # call transmute method with squeezed height.\n path = self.transmute(x0, y0, width, height, mutation_size)\n vertices, codes = path.vertices, path.codes\n # Restore the height\n vertices[:, 1] = vertices[:, 1] * aspect_ratio\n return Path(vertices, codes)\n else:\n return self.transmute(x0, y0, width, height, mutation_size)\n\n def __reduce__(self):\n # because we have decided to nest thes classes, we need to\n # add some more information to allow instance pickling.\n import matplotlib.cbook as cbook\n return (cbook._NestedClassGetter(),\n (BoxStyle, self.__class__.__name__),\n self.__dict__\n )\n\n class Square(_Base):\n \"\"\"\n A simple square box.\n \"\"\"\n\n def __init__(self, pad=0.3):\n \"\"\"\n *pad*\n amount of padding\n \"\"\"\n\n self.pad = pad\n super(BoxStyle.Square, self).__init__()\n\n def transmute(self, x0, y0, width, height, mutation_size):\n pad = mutation_size * self.pad\n\n # width and height with padding added.\n width, height = width + 2*pad, height + 2*pad\n\n # boundary of the padded box\n x0, y0 = x0 - pad, y0 - pad,\n x1, y1 = x0 + width, y0 + height\n\n vertices = [(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)]\n codes = [Path.MOVETO] + [Path.LINETO] * 3 + [Path.CLOSEPOLY]\n return Path(vertices, codes)\n\n _style_list[\"square\"] = Square\n\n class Circle(_Base):\n \"\"\"A simple circle box.\"\"\"\n def __init__(self, pad=0.3):\n \"\"\"\n Parameters\n ----------\n pad : float\n The amount of padding around the original box.\n \"\"\"\n self.pad = pad\n super(BoxStyle.Circle, self).__init__()\n\n def transmute(self, x0, y0, width, height, mutation_size):\n pad = mutation_size * self.pad\n width, height = width + 2 * pad, height + 2 * pad\n\n # boundary of the padded box\n x0, y0 = x0 - pad, y0 - pad,\n return Path.circle((x0 + width/2., y0 + height/2.),\n (max([width, height]) / 2.))\n\n _style_list[\"circle\"] = Circle\n\n class LArrow(_Base):\n \"\"\"\n (left) Arrow Box\n \"\"\"\n def __init__(self, pad=0.3):\n self.pad = pad\n super(BoxStyle.LArrow, self).__init__()\n\n def transmute(self, x0, y0, width, height, mutation_size):\n # padding\n pad = mutation_size * self.pad\n\n # width and height with padding added.\n width, height = width + 2. * pad, \\\n height + 2. * pad,\n\n # boundary of the padded box\n x0, y0 = x0 - pad, y0 - pad,\n x1, y1 = x0 + width, y0 + height\n\n dx = (y1 - y0) / 2.\n dxx = dx * .5\n # adjust x0. 1.4 <- sqrt(2)\n x0 = x0 + pad / 1.4\n\n cp = [(x0 + dxx, y0), (x1, y0), (x1, y1), (x0 + dxx, y1),\n (x0 + dxx, y1 + dxx), (x0 - dx, y0 + dx),\n (x0 + dxx, y0 - dxx), # arrow\n (x0 + dxx, y0), (x0 + dxx, y0)]\n\n com = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO,\n Path.LINETO, Path.LINETO, Path.LINETO,\n Path.LINETO, Path.CLOSEPOLY]\n\n path = Path(cp, com)\n\n return path\n _style_list[\"larrow\"] = LArrow\n\n class RArrow(LArrow):\n \"\"\"\n (right) Arrow Box\n \"\"\"\n\n def __init__(self, pad=0.3):\n #self.pad = pad\n super(BoxStyle.RArrow, self).__init__(pad)\n\n def transmute(self, x0, y0, width, height, mutation_size):\n\n p = BoxStyle.LArrow.transmute(self, x0, y0,\n width, height, mutation_size)\n\n p.vertices[:, 0] = 2 * x0 + width - p.vertices[:, 0]\n\n return p\n\n _style_list[\"rarrow\"] = RArrow\n\n class Round(_Base):\n \"\"\"\n A box with round corners.\n \"\"\"\n\n def __init__(self, pad=0.3, rounding_size=None):\n \"\"\"\n *pad*\n amount of padding\n\n *rounding_size*\n rounding radius of corners. *pad* if None\n \"\"\"\n self.pad = pad\n self.rounding_size = rounding_size\n super(BoxStyle.Round, self).__init__()\n\n def transmute(self, x0, y0, width, height, mutation_size):\n\n # padding\n pad = mutation_size * self.pad\n\n # size of the roudning corner\n if self.rounding_size:\n dr = mutation_size * self.rounding_size\n else:\n dr = pad\n\n width, height = width + 2. * pad, \\\n height + 2. * pad,\n\n x0, y0 = x0 - pad, y0 - pad,\n x1, y1 = x0 + width, y0 + height\n\n # Round corners are implemented as quadratic bezier. e.g.,\n # [(x0, y0-dr), (x0, y0), (x0+dr, y0)] for lower left corner.\n cp = [(x0 + dr, y0),\n (x1 - dr, y0),\n (x1, y0), (x1, y0 + dr),\n (x1, y1 - dr),\n (x1, y1), (x1 - dr, y1),\n (x0 + dr, y1),\n (x0, y1), (x0, y1 - dr),\n (x0, y0 + dr),\n (x0, y0), (x0 + dr, y0),\n (x0 + dr, y0)]\n\n com = [Path.MOVETO,\n Path.LINETO,\n Path.CURVE3, Path.CURVE3,\n Path.LINETO,\n Path.CURVE3, Path.CURVE3,\n Path.LINETO,\n Path.CURVE3, Path.CURVE3,\n Path.LINETO,\n Path.CURVE3, Path.CURVE3,\n Path.CLOSEPOLY]\n\n path = Path(cp, com)\n\n return path\n\n _style_list[\"round\"] = Round\n\n class Round4(_Base):\n \"\"\"\n Another box with round edges.\n \"\"\"\n\n def __init__(self, pad=0.3, rounding_size=None):\n \"\"\"\n *pad*\n amount of padding\n\n *rounding_size*\n rounding size of edges. *pad* if None\n \"\"\"\n\n self.pad = pad\n self.rounding_size = rounding_size\n super(BoxStyle.Round4, self).__init__()\n\n def transmute(self, x0, y0, width, height, mutation_size):\n\n # padding\n pad = mutation_size * self.pad\n\n # roudning size. Use a half of the pad if not set.\n if self.rounding_size:\n dr = mutation_size * self.rounding_size\n else:\n dr = pad / 2.\n\n width, height = width + 2. * pad - 2 * dr, \\\n height + 2. * pad - 2 * dr,\n\n x0, y0 = x0 - pad + dr, y0 - pad + dr,\n x1, y1 = x0 + width, y0 + height\n\n cp = [(x0, y0),\n (x0 + dr, y0 - dr), (x1 - dr, y0 - dr), (x1, y0),\n (x1 + dr, y0 + dr), (x1 + dr, y1 - dr), (x1, y1),\n (x1 - dr, y1 + dr), (x0 + dr, y1 + dr), (x0, y1),\n (x0 - dr, y1 - dr), (x0 - dr, y0 + dr), (x0, y0),\n (x0, y0)]\n\n com = [Path.MOVETO,\n Path.CURVE4, Path.CURVE4, Path.CURVE4,\n Path.CURVE4, Path.CURVE4, Path.CURVE4,\n Path.CURVE4, Path.CURVE4, Path.CURVE4,\n Path.CURVE4, Path.CURVE4, Path.CURVE4,\n Path.CLOSEPOLY]\n\n path = Path(cp, com)\n\n return path\n\n _style_list[\"round4\"] = Round4\n\n class Sawtooth(_Base):\n \"\"\"\n A sawtooth box.\n \"\"\"\n\n def __init__(self, pad=0.3, tooth_size=None):\n \"\"\"\n *pad*\n amount of padding\n\n *tooth_size*\n size of the sawtooth. pad* if None\n \"\"\"\n self.pad = pad\n self.tooth_size = tooth_size\n super(BoxStyle.Sawtooth, self).__init__()\n\n def _get_sawtooth_vertices(self, x0, y0, width, height, mutation_size):\n\n # padding\n pad = mutation_size * self.pad\n\n # size of sawtooth\n if self.tooth_size is None:\n tooth_size = self.pad * .5 * mutation_size\n else:\n tooth_size = self.tooth_size * mutation_size\n\n tooth_size2 = tooth_size / 2.\n width, height = width + 2. * pad - tooth_size, \\\n height + 2. * pad - tooth_size,\n\n # the sizes of the vertical and horizontal sawtooth are\n # separately adjusted to fit the given box size.\n dsx_n = int(round((width - tooth_size) / (tooth_size * 2))) * 2\n dsx = (width - tooth_size) / dsx_n\n dsy_n = int(round((height - tooth_size) / (tooth_size * 2))) * 2\n dsy = (height - tooth_size) / dsy_n\n\n x0, y0 = x0 - pad + tooth_size2, y0 - pad + tooth_size2\n x1, y1 = x0 + width, y0 + height\n\n bottom_saw_x = [x0] + \\\n [x0 + tooth_size2 + dsx * .5 * i\n for i\n in range(dsx_n * 2)] + \\\n [x1 - tooth_size2]\n\n bottom_saw_y = [y0] + \\\n [y0 - tooth_size2, y0,\n y0 + tooth_size2, y0] * dsx_n + \\\n [y0 - tooth_size2]\n\n right_saw_x = [x1] + \\\n [x1 + tooth_size2,\n x1,\n x1 - tooth_size2,\n x1] * dsx_n + \\\n [x1 + tooth_size2]\n\n right_saw_y = [y0] + \\\n [y0 + tooth_size2 + dsy * .5 * i\n for i\n in range(dsy_n * 2)] + \\\n [y1 - tooth_size2]\n\n top_saw_x = [x1] + \\\n [x1 - tooth_size2 - dsx * .5 * i\n for i\n in range(dsx_n * 2)] + \\\n [x0 + tooth_size2]\n\n top_saw_y = [y1] + \\\n [y1 + tooth_size2,\n y1,\n y1 - tooth_size2,\n y1] * dsx_n + \\\n [y1 + tooth_size2]\n\n left_saw_x = [x0] + \\\n [x0 - tooth_size2,\n x0,\n x0 + tooth_size2,\n x0] * dsy_n + \\\n [x0 - tooth_size2]\n\n left_saw_y = [y1] + \\\n [y1 - tooth_size2 - dsy * .5 * i\n for i\n in range(dsy_n * 2)] + \\\n [y0 + tooth_size2]\n\n saw_vertices = list(zip(bottom_saw_x, bottom_saw_y)) + \\\n list(zip(right_saw_x, right_saw_y)) + \\\n list(zip(top_saw_x, top_saw_y)) + \\\n list(zip(left_saw_x, left_saw_y)) + \\\n [(bottom_saw_x[0], bottom_saw_y[0])]\n\n return saw_vertices\n\n def transmute(self, x0, y0, width, height, mutation_size):\n\n saw_vertices = self._get_sawtooth_vertices(x0, y0, width,\n height, mutation_size)\n path = Path(saw_vertices, closed=True)\n return path\n\n _style_list[\"sawtooth\"] = Sawtooth\n\n class Roundtooth(Sawtooth):\n \"\"\"A rounded tooth box.\"\"\"\n def __init__(self, pad=0.3, tooth_size=None):\n \"\"\"\n *pad*\n amount of padding\n\n *tooth_size*\n size of the sawtooth. pad* if None\n \"\"\"\n super(BoxStyle.Roundtooth, self).__init__(pad, tooth_size)\n\n def transmute(self, x0, y0, width, height, mutation_size):\n saw_vertices = self._get_sawtooth_vertices(x0, y0,\n width, height,\n mutation_size)\n # Add a trailing vertex to allow us to close the polygon correctly\n saw_vertices = np.concatenate([np.array(saw_vertices),\n [saw_vertices[0]]], axis=0)\n codes = ([Path.MOVETO] +\n [Path.CURVE3, Path.CURVE3] * ((len(saw_vertices)-1) // 2) +\n [Path.CLOSEPOLY])\n print(len(codes), saw_vertices.shape)\n return Path(saw_vertices, codes)\n\n _style_list[\"roundtooth\"] = Roundtooth\n\n if __doc__: # __doc__ could be None if -OO optimization is enabled\n __doc__ = cbook.dedent(__doc__) % \\\n {\"AvailableBoxstyles\": _pprint_styles(_style_list)}\n\ndocstring.interpd.update(\n AvailableBoxstyles=_pprint_styles(BoxStyle._style_list))\n\n\nclass FancyBboxPatch(Patch):\n \"\"\"\n Draw a fancy box around a rectangle with lower left at *xy*=(*x*,\n *y*) with specified width and height.\n\n :class:`FancyBboxPatch` class is similar to :class:`Rectangle`\n class, but it draws a fancy box around the rectangle. The\n transformation of the rectangle box to the fancy box is delegated\n to the :class:`BoxTransmuterBase` and its derived classes.\n\n \"\"\"\n\n def __str__(self):\n return self.__class__.__name__ \\\n + \"(%g,%g;%gx%g)\" % (self._x, self._y,\n self._width, self._height)\n\n @docstring.dedent_interpd\n def __init__(self, xy, width, height,\n boxstyle=\"round\",\n bbox_transmuter=None,\n mutation_scale=1.,\n mutation_aspect=None,\n **kwargs):\n \"\"\"\n *xy* = lower left corner\n\n *width*, *height*\n\n *boxstyle* determines what kind of fancy box will be drawn. It\n can be a string of the style name with a comma separated\n attribute, or an instance of :class:`BoxStyle`. Following box\n styles are available.\n\n %(AvailableBoxstyles)s\n\n *mutation_scale* : a value with which attributes of boxstyle\n (e.g., pad) will be scaled. default=1.\n\n *mutation_aspect* : The height of the rectangle will be\n squeezed by this value before the mutation and the mutated\n box will be stretched by the inverse of it. default=None.\n\n Valid kwargs are:\n %(Patch)s\n \"\"\"\n\n Patch.__init__(self, **kwargs)\n\n self._x = xy[0]\n self._y = xy[1]\n self._width = width\n self._height = height\n\n if boxstyle == \"custom\":\n if bbox_transmuter is None:\n raise ValueError(\"bbox_transmuter argument is needed with \"\n \"custom boxstyle\")\n self._bbox_transmuter = bbox_transmuter\n else:\n self.set_boxstyle(boxstyle)\n\n self._mutation_scale = mutation_scale\n self._mutation_aspect = mutation_aspect\n\n @docstring.dedent_interpd\n def set_boxstyle(self, boxstyle=None, **kw):\n \"\"\"\n Set the box style.\n\n *boxstyle* can be a string with boxstyle name with optional\n comma-separated attributes. Alternatively, the attrs can\n be provided as keywords::\n\n set_boxstyle(\"round,pad=0.2\")\n set_boxstyle(\"round\", pad=0.2)\n\n Old attrs simply are forgotten.\n\n Without argument (or with *boxstyle* = None), it returns\n available box styles.\n\n ACCEPTS: %(AvailableBoxstyles)s\n\n \"\"\"\n if boxstyle is None:\n return BoxStyle.pprint_styles()\n\n if isinstance(boxstyle, BoxStyle._Base):\n self._bbox_transmuter = boxstyle\n elif six.callable(boxstyle):\n self._bbox_transmuter = boxstyle\n else:\n self._bbox_transmuter = BoxStyle(boxstyle, **kw)\n\n def set_mutation_scale(self, scale):\n \"\"\"\n Set the mutation scale.\n\n ACCEPTS: float\n \"\"\"\n self._mutation_scale = scale\n\n def get_mutation_scale(self):\n \"\"\"\n Return the mutation scale.\n \"\"\"\n return self._mutation_scale\n\n def set_mutation_aspect(self, aspect):\n \"\"\"\n Set the aspect ratio of the bbox mutation.\n\n ACCEPTS: float\n \"\"\"\n self._mutation_aspect = aspect\n\n def get_mutation_aspect(self):\n \"\"\"\n Return the aspect ratio of the bbox mutation.\n \"\"\"\n return self._mutation_aspect\n\n def get_boxstyle(self):\n \"Return the boxstyle object\"\n return self._bbox_transmuter\n\n def get_path(self):\n \"\"\"\n Return the mutated path of the rectangle\n \"\"\"\n\n _path = self.get_boxstyle()(self._x, self._y,\n self._width, self._height,\n self.get_mutation_scale(),\n self.get_mutation_aspect())\n return _path\n\n # Following methods are borrowed from the Rectangle class.\n\n def get_x(self):\n \"Return the left coord of the rectangle\"\n return self._x\n\n def get_y(self):\n \"Return the bottom coord of the rectangle\"\n return self._y\n\n def get_width(self):\n \"Return the width of the rectangle\"\n return self._width\n\n def get_height(self):\n \"Return the height of the rectangle\"\n return self._height\n\n def set_x(self, x):\n \"\"\"\n Set the left coord of the rectangle\n\n ACCEPTS: float\n \"\"\"\n self._x = x\n\n def set_y(self, y):\n \"\"\"\n Set the bottom coord of the rectangle\n\n ACCEPTS: float\n \"\"\"\n self._y = y\n\n def set_width(self, w):\n \"\"\"\n Set the width rectangle\n\n ACCEPTS: float\n \"\"\"\n self._width = w\n\n def set_height(self, h):\n \"\"\"\n Set the width rectangle\n\n ACCEPTS: float\n \"\"\"\n self._height = h\n\n def set_bounds(self, *args):\n \"\"\"\n Set the bounds of the rectangle: l,b,w,h\n\n ACCEPTS: (left, bottom, width, height)\n \"\"\"\n if len(args) == 0:\n l, b, w, h = args[0]\n else:\n l, b, w, h = args\n self._x = l\n self._y = b\n self._width = w\n self._height = h\n\n def get_bbox(self):\n return transforms.Bbox.from_bounds(self._x, self._y,\n self._width, self._height)\n\n\nfrom matplotlib.bezier import split_bezier_intersecting_with_closedpath\nfrom matplotlib.bezier import get_intersection, inside_circle, get_parallels\nfrom matplotlib.bezier import make_wedged_bezier2\nfrom matplotlib.bezier import split_path_inout, get_cos_sin\nfrom matplotlib.bezier import make_path_regular, concatenate_paths\n\n\nclass ConnectionStyle(_Style):\n \"\"\"\n :class:`ConnectionStyle` is a container class which defines\n several connectionstyle classes, which is used to create a path\n between two points. These are mainly used with\n :class:`FancyArrowPatch`.\n\n A connectionstyle object can be either created as::\n\n ConnectionStyle.Arc3(rad=0.2)\n\n or::\n\n ConnectionStyle(\"Arc3\", rad=0.2)\n\n or::\n\n ConnectionStyle(\"Arc3, rad=0.2\")\n\n The following classes are defined\n\n %(AvailableConnectorstyles)s\n\n\n An instance of any connection style class is an callable object,\n whose call signature is::\n\n __call__(self, posA, posB,\n patchA=None, patchB=None,\n shrinkA=2., shrinkB=2.)\n\n and it returns a :class:`Path` instance. *posA* and *posB* are\n tuples of x,y coordinates of the two points to be\n connected. *patchA* (or *patchB*) is given, the returned path is\n clipped so that it start (or end) from the boundary of the\n patch. The path is further shrunk by *shrinkA* (or *shrinkB*)\n which is given in points.\n\n \"\"\"\n\n _style_list = {}\n\n class _Base(object):\n \"\"\"\n A base class for connectionstyle classes. The dervided needs\n to implement a *connect* methods whose call signature is::\n\n connect(posA, posB)\n\n where posA and posB are tuples of x, y coordinates to be\n connected. The methods needs to return a path connecting two\n points. This base class defines a __call__ method, and few\n helper methods.\n \"\"\"\n\n class SimpleEvent:\n def __init__(self, xy):\n self.x, self.y = xy\n\n def _clip(self, path, patchA, patchB):\n \"\"\"\n Clip the path to the boundary of the patchA and patchB.\n The starting point of the path needed to be inside of the\n patchA and the end point inside the patch B. The *contains*\n methods of each patch object is utilized to test if the point\n is inside the path.\n \"\"\"\n\n if patchA:\n def insideA(xy_display):\n xy_event = ConnectionStyle._Base.SimpleEvent(xy_display)\n return patchA.contains(xy_event)[0]\n\n try:\n left, right = split_path_inout(path, insideA)\n except ValueError:\n right = path\n\n path = right\n\n if patchB:\n def insideB(xy_display):\n xy_event = ConnectionStyle._Base.SimpleEvent(xy_display)\n return patchB.contains(xy_event)[0]\n\n try:\n left, right = split_path_inout(path, insideB)\n except ValueError:\n left = path\n\n path = left\n\n return path\n\n def _shrink(self, path, shrinkA, shrinkB):\n \"\"\"\n Shrink the path by fixed size (in points) with shrinkA and shrinkB\n \"\"\"\n if shrinkA:\n x, y = path.vertices[0]\n insideA = inside_circle(x, y, shrinkA)\n\n try:\n left, right = split_path_inout(path, insideA)\n path = right\n except ValueError:\n pass\n\n if shrinkB:\n x, y = path.vertices[-1]\n insideB = inside_circle(x, y, shrinkB)\n\n try:\n left, right = split_path_inout(path, insideB)\n path = left\n except ValueError:\n pass\n\n return path\n\n def __call__(self, posA, posB,\n shrinkA=2., shrinkB=2., patchA=None, patchB=None):\n \"\"\"\n Calls the *connect* method to create a path between *posA*\n and *posB*. The path is clipped and shrinked.\n \"\"\"\n\n path = self.connect(posA, posB)\n\n clipped_path = self._clip(path, patchA, patchB)\n shrinked_path = self._shrink(clipped_path, shrinkA, shrinkB)\n\n return shrinked_path\n\n def __reduce__(self):\n # because we have decided to nest thes classes, we need to\n # add some more information to allow instance pickling.\n import matplotlib.cbook as cbook\n return (cbook._NestedClassGetter(),\n (ConnectionStyle, self.__class__.__name__),\n self.__dict__\n )\n\n class Arc3(_Base):\n \"\"\"\n Creates a simple quadratic bezier curve between two\n points. The curve is created so that the middle contol points\n (C1) is located at the same distance from the start (C0) and\n end points(C2) and the distance of the C1 to the line\n connecting C0-C2 is *rad* times the distance of C0-C2.\n \"\"\"\n\n def __init__(self, rad=0.):\n \"\"\"\n *rad*\n curvature of the curve.\n \"\"\"\n self.rad = rad\n\n def connect(self, posA, posB):\n x1, y1 = posA\n x2, y2 = posB\n x12, y12 = (x1 + x2) / 2., (y1 + y2) / 2.\n dx, dy = x2 - x1, y2 - y1\n\n f = self.rad\n\n cx, cy = x12 + f * dy, y12 - f * dx\n\n vertices = [(x1, y1),\n (cx, cy),\n (x2, y2)]\n codes = [Path.MOVETO,\n Path.CURVE3,\n Path.CURVE3]\n\n return Path(vertices, codes)\n\n _style_list[\"arc3\"] = Arc3\n\n class Angle3(_Base):\n \"\"\"\n Creates a simple quadratic bezier curve between two\n points. The middle control points is placed at the\n intersecting point of two lines which crosses the start (or\n end) point and has a angle of angleA (or angleB).\n \"\"\"\n\n def __init__(self, angleA=90, angleB=0):\n \"\"\"\n *angleA*\n starting angle of the path\n\n *angleB*\n ending angle of the path\n \"\"\"\n\n self.angleA = angleA\n self.angleB = angleB\n\n def connect(self, posA, posB):\n x1, y1 = posA\n x2, y2 = posB\n\n cosA, sinA = math.cos(self.angleA / 180. * math.pi),\\\n math.sin(self.angleA / 180. * math.pi),\n cosB, sinB = math.cos(self.angleB / 180. * math.pi),\\\n math.sin(self.angleB / 180. * math.pi),\n\n cx, cy = get_intersection(x1, y1, cosA, sinA,\n x2, y2, cosB, sinB)\n\n vertices = [(x1, y1), (cx, cy), (x2, y2)]\n codes = [Path.MOVETO, Path.CURVE3, Path.CURVE3]\n\n return Path(vertices, codes)\n\n _style_list[\"angle3\"] = Angle3\n\n class Angle(_Base):\n \"\"\"\n Creates a picewise continuous quadratic bezier path between\n two points. The path has a one passing-through point placed at\n the intersecting point of two lines which crosses the start\n (or end) point and has a angle of angleA (or angleB). The\n connecting edges are rounded with *rad*.\n \"\"\"\n\n def __init__(self, angleA=90, angleB=0, rad=0.):\n \"\"\"\n *angleA*\n starting angle of the path\n\n *angleB*\n ending angle of the path\n\n *rad*\n rounding radius of the edge\n \"\"\"\n\n self.angleA = angleA\n self.angleB = angleB\n\n self.rad = rad\n\n def connect(self, posA, posB):\n x1, y1 = posA\n x2, y2 = posB\n\n cosA, sinA = math.cos(self.angleA / 180. * math.pi),\\\n math.sin(self.angleA / 180. * math.pi),\n cosB, sinB = math.cos(self.angleB / 180. * math.pi),\\\n math.sin(self.angleB / 180. * math.pi),\n\n cx, cy = get_intersection(x1, y1, cosA, sinA,\n x2, y2, cosB, sinB)\n\n vertices = [(x1, y1)]\n codes = [Path.MOVETO]\n\n if self.rad == 0.:\n vertices.append((cx, cy))\n codes.append(Path.LINETO)\n else:\n dx1, dy1 = x1 - cx, y1 - cy\n d1 = (dx1 ** 2 + dy1 ** 2) ** .5\n f1 = self.rad / d1\n dx2, dy2 = x2 - cx, y2 - cy\n d2 = (dx2 ** 2 + dy2 ** 2) ** .5\n f2 = self.rad / d2\n vertices.extend([(cx + dx1 * f1, cy + dy1 * f1),\n (cx, cy),\n (cx + dx2 * f2, cy + dy2 * f2)])\n codes.extend([Path.LINETO, Path.CURVE3, Path.CURVE3])\n\n vertices.append((x2, y2))\n codes.append(Path.LINETO)\n\n return Path(vertices, codes)\n\n _style_list[\"angle\"] = Angle\n\n class Arc(_Base):\n \"\"\"\n Creates a picewise continuous quadratic bezier path between\n two points. The path can have two passing-through points, a\n point placed at the distance of armA and angle of angleA from\n point A, another point with respect to point B. The edges are\n rounded with *rad*.\n \"\"\"\n\n def __init__(self, angleA=0, angleB=0, armA=None, armB=None, rad=0.):\n \"\"\"\n *angleA* :\n starting angle of the path\n\n *angleB* :\n ending angle of the path\n\n *armA* :\n length of the starting arm\n\n *armB* :\n length of the ending arm\n\n *rad* :\n rounding radius of the edges\n \"\"\"\n\n self.angleA = angleA\n self.angleB = angleB\n self.armA = armA\n self.armB = armB\n\n self.rad = rad\n\n def connect(self, posA, posB):\n x1, y1 = posA\n x2, y2 = posB\n\n vertices = [(x1, y1)]\n rounded = []\n codes = [Path.MOVETO]\n\n if self.armA:\n cosA = math.cos(self.angleA / 180. * math.pi)\n sinA = math.sin(self.angleA / 180. * math.pi)\n #x_armA, y_armB\n d = self.armA - self.rad\n rounded.append((x1 + d * cosA, y1 + d * sinA))\n d = self.armA\n rounded.append((x1 + d * cosA, y1 + d * sinA))\n\n if self.armB:\n cosB = math.cos(self.angleB / 180. * math.pi)\n sinB = math.sin(self.angleB / 180. * math.pi)\n x_armB, y_armB = x2 + self.armB * cosB, y2 + self.armB * sinB\n\n if rounded:\n xp, yp = rounded[-1]\n dx, dy = x_armB - xp, y_armB - yp\n dd = (dx * dx + dy * dy) ** .5\n\n rounded.append((xp + self.rad * dx / dd,\n yp + self.rad * dy / dd))\n vertices.extend(rounded)\n codes.extend([Path.LINETO,\n Path.CURVE3,\n Path.CURVE3])\n else:\n xp, yp = vertices[-1]\n dx, dy = x_armB - xp, y_armB - yp\n dd = (dx * dx + dy * dy) ** .5\n\n d = dd - self.rad\n rounded = [(xp + d * dx / dd, yp + d * dy / dd),\n (x_armB, y_armB)]\n\n if rounded:\n xp, yp = rounded[-1]\n dx, dy = x2 - xp, y2 - yp\n dd = (dx * dx + dy * dy) ** .5\n\n rounded.append((xp + self.rad * dx / dd,\n yp + self.rad * dy / dd))\n vertices.extend(rounded)\n codes.extend([Path.LINETO,\n Path.CURVE3,\n Path.CURVE3])\n\n vertices.append((x2, y2))\n codes.append(Path.LINETO)\n\n return Path(vertices, codes)\n\n _style_list[\"arc\"] = Arc\n\n class Bar(_Base):\n \"\"\"\n A line with *angle* between A and B with *armA* and\n *armB*. One of the arm is extend so that they are connected in\n a right angle. The length of armA is determined by (*armA*\n + *fraction* x AB distance). Same for armB.\n \"\"\"\n\n def __init__(self, armA=0., armB=0., fraction=0.3, angle=None):\n \"\"\"\n *armA* : minimum length of armA\n\n *armB* : minimum length of armB\n\n *fraction* : a fraction of the distance between two points that\n will be added to armA and armB.\n\n *angle* : angle of the connecting line (if None, parallel to A\n and B)\n \"\"\"\n self.armA = armA\n self.armB = armB\n self.fraction = fraction\n self.angle = angle\n\n def connect(self, posA, posB):\n x1, y1 = posA\n x20, y20 = x2, y2 = posB\n\n x12, y12 = (x1 + x2) / 2., (y1 + y2) / 2.\n\n theta1 = math.atan2(y2 - y1, x2 - x1)\n dx, dy = x2 - x1, y2 - y1\n dd = (dx * dx + dy * dy) ** .5\n ddx, ddy = dx / dd, dy / dd\n\n armA, armB = self.armA, self.armB\n\n if self.angle is not None:\n #angle = self.angle % 180.\n #if angle < 0. or angle > 180.:\n # angle\n #theta0 = (self.angle%180.)/180.*math.pi\n theta0 = self.angle / 180. * math.pi\n #theta0 = (((self.angle+90)%180.) - 90.)/180.*math.pi\n dtheta = theta1 - theta0\n dl = dd * math.sin(dtheta)\n\n dL = dd * math.cos(dtheta)\n\n #x2, y2 = x2 + dl*ddy, y2 - dl*ddx\n x2, y2 = x1 + dL * math.cos(theta0), y1 + dL * math.sin(theta0)\n\n armB = armB - dl\n\n # update\n dx, dy = x2 - x1, y2 - y1\n dd2 = (dx * dx + dy * dy) ** .5\n ddx, ddy = dx / dd2, dy / dd2\n\n else:\n dl = 0.\n\n #if armA > armB:\n # armB = armA + dl\n #else:\n # armA = armB - dl\n\n arm = max(armA, armB)\n f = self.fraction * dd + arm\n #fB = self.fraction*dd + armB\n\n cx1, cy1 = x1 + f * ddy, y1 - f * ddx\n cx2, cy2 = x2 + f * ddy, y2 - f * ddx\n\n vertices = [(x1, y1),\n (cx1, cy1),\n (cx2, cy2),\n (x20, y20)]\n codes = [Path.MOVETO,\n Path.LINETO,\n Path.LINETO,\n Path.LINETO]\n\n return Path(vertices, codes)\n\n _style_list[\"bar\"] = Bar\n\n if __doc__:\n __doc__ = cbook.dedent(__doc__) % \\\n {\"AvailableConnectorstyles\": _pprint_styles(_style_list)}\n\n\ndef _point_along_a_line(x0, y0, x1, y1, d):\n \"\"\"\n find a point along a line connecting (x0, y0) -- (x1, y1) whose\n distance from (x0, y0) is d.\n \"\"\"\n dx, dy = x0 - x1, y0 - y1\n ff = d / (dx * dx + dy * dy) ** .5\n x2, y2 = x0 - ff * dx, y0 - ff * dy\n\n return x2, y2\n\n\nclass ArrowStyle(_Style):\n \"\"\"\n :class:`ArrowStyle` is a container class which defines several\n arrowstyle classes, which is used to create an arrow path along a\n given path. These are mainly used with :class:`FancyArrowPatch`.\n\n A arrowstyle object can be either created as::\n\n ArrowStyle.Fancy(head_length=.4, head_width=.4, tail_width=.4)\n\n or::\n\n ArrowStyle(\"Fancy\", head_length=.4, head_width=.4, tail_width=.4)\n\n or::\n\n ArrowStyle(\"Fancy, head_length=.4, head_width=.4, tail_width=.4\")\n\n The following classes are defined\n\n %(AvailableArrowstyles)s\n\n\n An instance of any arrow style class is an callable object,\n whose call signature is::\n\n __call__(self, path, mutation_size, linewidth, aspect_ratio=1.)\n\n and it returns a tuple of a :class:`Path` instance and a boolean\n value. *path* is a :class:`Path` instance along witch the arrow\n will be drawn. *mutation_size* and *aspect_ratio* has a same\n meaning as in :class:`BoxStyle`. *linewidth* is a line width to be\n stroked. This is meant to be used to correct the location of the\n head so that it does not overshoot the destination point, but not all\n classes support it.\n\n .. plot:: mpl_examples/pylab_examples/fancyarrow_demo.py\n \"\"\"\n\n _style_list = {}\n\n class _Base(object):\n \"\"\"\n Arrow Transmuter Base class\n\n ArrowTransmuterBase and its derivatives are used to make a fancy\n arrow around a given path. The __call__ method returns a path\n (which will be used to create a PathPatch instance) and a boolean\n value indicating the path is open therefore is not fillable. This\n class is not an artist and actual drawing of the fancy arrow is\n done by the FancyArrowPatch class.\n\n \"\"\"\n\n # The derived classes are required to be able to be initialized\n # w/o arguments, i.e., all its argument (except self) must have\n # the default values.\n\n def __init__(self):\n super(ArrowStyle._Base, self).__init__()\n\n @staticmethod\n def ensure_quadratic_bezier(path):\n \"\"\" Some ArrowStyle class only wokrs with a simple\n quaratic bezier curve (created with Arc3Connetion or\n Angle3Connector). This static method is to check if the\n provided path is a simple quadratic bezier curve and returns\n its control points if true.\n \"\"\"\n segments = list(path.iter_segments())\n assert len(segments) == 2\n\n assert segments[0][1] == Path.MOVETO\n assert segments[1][1] == Path.CURVE3\n\n return list(segments[0][0]) + list(segments[1][0])\n\n def transmute(self, path, mutation_size, linewidth):\n \"\"\"\n The transmute method is a very core of the ArrowStyle\n class and must be overriden in the subclasses. It receives\n the path object along which the arrow will be drawn, and\n the mutation_size, with which the amount arrow head and\n etc. will be scaled. The linewidth may be used to adjust\n the the path so that it does not pass beyond the given\n points. It returns a tuple of a Path instance and a\n boolean. The boolean value indicate whether the path can\n be filled or not. The return value can also be a list of paths\n and list of booleans of a same length.\n \"\"\"\n\n raise NotImplementedError('Derived must override')\n\n def __call__(self, path, mutation_size, linewidth,\n aspect_ratio=1.):\n \"\"\"\n The __call__ method is a thin wrapper around the transmute method\n and take care of the aspect ratio.\n \"\"\"\n\n path = make_path_regular(path)\n\n if aspect_ratio is not None:\n # Squeeze the given height by the aspect_ratio\n\n vertices, codes = path.vertices[:], path.codes[:]\n # Squeeze the height\n vertices[:, 1] = vertices[:, 1] / aspect_ratio\n path_shrinked = Path(vertices, codes)\n # call transmute method with squeezed height.\n path_mutated, fillable = self.transmute(path_shrinked,\n linewidth,\n mutation_size)\n if cbook.iterable(fillable):\n path_list = []\n for p in zip(path_mutated):\n v, c = p.vertices, p.codes\n # Restore the height\n v[:, 1] = v[:, 1] * aspect_ratio\n path_list.append(Path(v, c))\n return path_list, fillable\n else:\n return path_mutated, fillable\n else:\n return self.transmute(path, mutation_size, linewidth)\n\n def __reduce__(self):\n # because we have decided to nest thes classes, we need to\n # add some more information to allow instance pickling.\n import matplotlib.cbook as cbook\n return (cbook._NestedClassGetter(),\n (ArrowStyle, self.__class__.__name__),\n self.__dict__\n )\n\n class _Curve(_Base):\n \"\"\"\n A simple arrow which will work with any path instance. The\n returned path is simply concatenation of the original path + at\n most two paths representing the arrow head at the begin point and the\n at the end point. The arrow heads can be either open or closed.\n \"\"\"\n\n def __init__(self, beginarrow=None, endarrow=None,\n fillbegin=False, fillend=False,\n head_length=.2, head_width=.1):\n \"\"\"\n The arrows are drawn if *beginarrow* and/or *endarrow* are\n true. *head_length* and *head_width* determines the size\n of the arrow relative to the *mutation scale*. The\n arrowhead at the begin (or end) is closed if fillbegin (or\n fillend) is True.\n \"\"\"\n self.beginarrow, self.endarrow = beginarrow, endarrow\n self.head_length, self.head_width = \\\n head_length, head_width\n self.fillbegin, self.fillend = fillbegin, fillend\n super(ArrowStyle._Curve, self).__init__()\n\n def _get_arrow_wedge(self, x0, y0, x1, y1,\n head_dist, cos_t, sin_t, linewidth\n ):\n \"\"\"\n Return the paths for arrow heads. Since arrow lines are\n drawn with capstyle=projected, The arrow goes beyond the\n desired point. This method also returns the amount of the path\n to be shrinked so that it does not overshoot.\n \"\"\"\n\n # arrow from x0, y0 to x1, y1\n\n dx, dy = x0 - x1, y0 - y1\n cp_distance = math.sqrt(dx ** 2 + dy ** 2)\n\n # pad_projected : amount of pad to account the\n # overshooting of the projection of the wedge\n pad_projected = (.5 * linewidth / sin_t)\n\n # apply pad for projected edge\n ddx = pad_projected * dx / cp_distance\n ddy = pad_projected * dy / cp_distance\n\n # offset for arrow wedge\n dx = dx / cp_distance * head_dist\n dy = dy / cp_distance * head_dist\n\n dx1, dy1 = cos_t * dx + sin_t * dy, -sin_t * dx + cos_t * dy\n dx2, dy2 = cos_t * dx - sin_t * dy, sin_t * dx + cos_t * dy\n\n vertices_arrow = [(x1 + ddx + dx1, y1 + ddy + dy1),\n (x1 + ddx, y1 + ddy),\n (x1 + ddx + dx2, y1 + ddy + dy2)]\n codes_arrow = [Path.MOVETO,\n Path.LINETO,\n Path.LINETO]\n\n return vertices_arrow, codes_arrow, ddx, ddy\n\n def transmute(self, path, mutation_size, linewidth):\n\n head_length, head_width = self.head_length * mutation_size, \\\n self.head_width * mutation_size\n head_dist = math.sqrt(head_length ** 2 + head_width ** 2)\n cos_t, sin_t = head_length / head_dist, head_width / head_dist\n\n # begin arrow\n x0, y0 = path.vertices[0]\n x1, y1 = path.vertices[1]\n\n if self.beginarrow:\n verticesA, codesA, ddxA, ddyA = \\\n self._get_arrow_wedge(x1, y1, x0, y0,\n head_dist, cos_t, sin_t,\n linewidth)\n else:\n verticesA, codesA = [], []\n ddxA, ddyA = 0., 0.\n\n # end arrow\n x2, y2 = path.vertices[-2]\n x3, y3 = path.vertices[-1]\n\n if self.endarrow:\n verticesB, codesB, ddxB, ddyB = \\\n self._get_arrow_wedge(x2, y2, x3, y3,\n head_dist, cos_t, sin_t,\n linewidth)\n else:\n verticesB, codesB = [], []\n ddxB, ddyB = 0., 0.\n\n # this simple code will not work if ddx, ddy is greater than\n # separation bettern vertices.\n _path = [Path(np.concatenate([[(x0 + ddxA, y0 + ddyA)],\n path.vertices[1:-1],\n [(x3 + ddxB, y3 + ddyB)]]),\n path.codes)]\n _fillable = [False]\n\n if self.beginarrow:\n if self.fillbegin:\n p = np.concatenate([verticesA, [verticesA[0],\n verticesA[0]], ])\n c = np.concatenate([codesA, [Path.LINETO, Path.CLOSEPOLY]])\n _path.append(Path(p, c))\n _fillable.append(True)\n else:\n _path.append(Path(verticesA, codesA))\n _fillable.append(False)\n\n if self.endarrow:\n if self.fillend:\n _fillable.append(True)\n p = np.concatenate([verticesB, [verticesB[0],\n verticesB[0]], ])\n c = np.concatenate([codesB, [Path.LINETO, Path.CLOSEPOLY]])\n _path.append(Path(p, c))\n else:\n _fillable.append(False)\n _path.append(Path(verticesB, codesB))\n\n return _path, _fillable\n\n class Curve(_Curve):\n \"\"\"\n A simple curve without any arrow head.\n \"\"\"\n\n def __init__(self):\n super(ArrowStyle.Curve, self).__init__(\n beginarrow=False, endarrow=False)\n\n _style_list[\"-\"] = Curve\n\n class CurveA(_Curve):\n \"\"\"\n An arrow with a head at its begin point.\n \"\"\"\n\n def __init__(self, head_length=.4, head_width=.2):\n \"\"\"\n *head_length*\n length of the arrow head\n\n *head_width*\n width of the arrow head\n \"\"\"\n\n super(ArrowStyle.CurveA, self).__init__(\n beginarrow=True, endarrow=False,\n head_length=head_length, head_width=head_width)\n\n _style_list[\"<-\"] = CurveA\n\n class CurveB(_Curve):\n \"\"\"\n An arrow with a head at its end point.\n \"\"\"\n\n def __init__(self, head_length=.4, head_width=.2):\n \"\"\"\n *head_length*\n length of the arrow head\n\n *head_width*\n width of the arrow head\n \"\"\"\n\n super(ArrowStyle.CurveB, self).__init__(\n beginarrow=False, endarrow=True,\n head_length=head_length, head_width=head_width)\n\n _style_list[\"->\"] = CurveB\n\n class CurveAB(_Curve):\n \"\"\"\n An arrow with heads both at the begin and the end point.\n \"\"\"\n\n def __init__(self, head_length=.4, head_width=.2):\n \"\"\"\n *head_length*\n length of the arrow head\n\n *head_width*\n width of the arrow head\n \"\"\"\n\n super(ArrowStyle.CurveAB, self).__init__(\n beginarrow=True, endarrow=True,\n head_length=head_length, head_width=head_width)\n\n _style_list[\"<->\"] = CurveAB\n\n class CurveFilledA(_Curve):\n \"\"\"\n An arrow with filled triangle head at the begin.\n \"\"\"\n\n def __init__(self, head_length=.4, head_width=.2):\n \"\"\"\n *head_length*\n length of the arrow head\n\n *head_width*\n width of the arrow head\n \"\"\"\n\n super(ArrowStyle.CurveFilledA, self).__init__(\n beginarrow=True, endarrow=False,\n fillbegin=True, fillend=False,\n head_length=head_length, head_width=head_width)\n\n _style_list[\"<|-\"] = CurveFilledA\n\n class CurveFilledB(_Curve):\n \"\"\"\n An arrow with filled triangle head at the end.\n \"\"\"\n\n def __init__(self, head_length=.4, head_width=.2):\n \"\"\"\n *head_length*\n length of the arrow head\n\n *head_width*\n width of the arrow head\n \"\"\"\n\n super(ArrowStyle.CurveFilledB, self).__init__(\n beginarrow=False, endarrow=True,\n fillbegin=False, fillend=True,\n head_length=head_length, head_width=head_width)\n\n _style_list[\"-|>\"] = CurveFilledB\n\n class CurveFilledAB(_Curve):\n \"\"\"\n An arrow with filled triangle heads both at the begin and the end\n point.\n \"\"\"\n\n def __init__(self, head_length=.4, head_width=.2):\n \"\"\"\n *head_length*\n length of the arrow head\n\n *head_width*\n width of the arrow head\n \"\"\"\n\n super(ArrowStyle.CurveFilledAB, self).__init__(\n beginarrow=True, endarrow=True,\n fillbegin=True, fillend=True,\n head_length=head_length, head_width=head_width)\n\n _style_list[\"<|-|>\"] = CurveFilledAB\n\n class _Bracket(_Base):\n\n def __init__(self, bracketA=None, bracketB=None,\n widthA=1., widthB=1.,\n lengthA=0.2, lengthB=0.2,\n angleA=None, angleB=None,\n scaleA=None, scaleB=None\n ):\n self.bracketA, self.bracketB = bracketA, bracketB\n self.widthA, self.widthB = widthA, widthB\n self.lengthA, self.lengthB = lengthA, lengthB\n self.angleA, self.angleB = angleA, angleB\n self.scaleA, self.scaleB = scaleA, scaleB\n\n def _get_bracket(self, x0, y0,\n cos_t, sin_t, width, length,\n ):\n\n # arrow from x0, y0 to x1, y1\n from matplotlib.bezier import get_normal_points\n x1, y1, x2, y2 = get_normal_points(x0, y0, cos_t, sin_t, width)\n\n dx, dy = length * cos_t, length * sin_t\n\n vertices_arrow = [(x1 + dx, y1 + dy),\n (x1, y1),\n (x2, y2),\n (x2 + dx, y2 + dy)]\n codes_arrow = [Path.MOVETO,\n Path.LINETO,\n Path.LINETO,\n Path.LINETO]\n\n return vertices_arrow, codes_arrow\n\n def transmute(self, path, mutation_size, linewidth):\n\n if self.scaleA is None:\n scaleA = mutation_size\n else:\n scaleA = self.scaleA\n\n if self.scaleB is None:\n scaleB = mutation_size\n else:\n scaleB = self.scaleB\n\n vertices_list, codes_list = [], []\n\n if self.bracketA:\n x0, y0 = path.vertices[0]\n x1, y1 = path.vertices[1]\n cos_t, sin_t = get_cos_sin(x1, y1, x0, y0)\n verticesA, codesA = self._get_bracket(x0, y0, cos_t, sin_t,\n self.widthA * scaleA,\n self.lengthA * scaleA)\n vertices_list.append(verticesA)\n codes_list.append(codesA)\n\n vertices_list.append(path.vertices)\n codes_list.append(path.codes)\n\n if self.bracketB:\n x0, y0 = path.vertices[-1]\n x1, y1 = path.vertices[-2]\n cos_t, sin_t = get_cos_sin(x1, y1, x0, y0)\n verticesB, codesB = self._get_bracket(x0, y0, cos_t, sin_t,\n self.widthB * scaleB,\n self.lengthB * scaleB)\n vertices_list.append(verticesB)\n codes_list.append(codesB)\n\n vertices = np.concatenate(vertices_list)\n codes = np.concatenate(codes_list)\n\n p = Path(vertices, codes)\n\n return p, False\n\n class BracketAB(_Bracket):\n \"\"\"\n An arrow with a bracket(]) at both ends.\n \"\"\"\n\n def __init__(self,\n widthA=1., lengthA=0.2, angleA=None,\n widthB=1., lengthB=0.2, angleB=None):\n \"\"\"\n *widthA*\n width of the bracket\n\n *lengthA*\n length of the bracket\n\n *angleA*\n angle between the bracket and the line\n\n *widthB*\n width of the bracket\n\n *lengthB*\n length of the bracket\n\n *angleB*\n angle between the bracket and the line\n \"\"\"\n\n super(ArrowStyle.BracketAB, self).__init__(\n True, True, widthA=widthA, lengthA=lengthA,\n angleA=angleA, widthB=widthB, lengthB=lengthB,\n angleB=angleB)\n\n _style_list[\"]-[\"] = BracketAB\n\n class BracketA(_Bracket):\n \"\"\"\n An arrow with a bracket(]) at its end.\n \"\"\"\n\n def __init__(self, widthA=1., lengthA=0.2, angleA=None):\n \"\"\"\n *widthA*\n width of the bracket\n\n *lengthA*\n length of the bracket\n\n *angleA*\n angle between the bracket and the line\n \"\"\"\n\n super(ArrowStyle.BracketA, self).__init__(True, None,\n widthA=widthA, lengthA=lengthA, angleA=angleA)\n\n _style_list[\"]-\"] = BracketA\n\n class BracketB(_Bracket):\n \"\"\"\n An arrow with a bracket([) at its end.\n \"\"\"\n\n def __init__(self, widthB=1., lengthB=0.2, angleB=None):\n \"\"\"\n *widthB*\n width of the bracket\n\n *lengthB*\n length of the bracket\n\n *angleB*\n angle between the bracket and the line\n \"\"\"\n\n super(ArrowStyle.BracketB, self).__init__(None, True,\n widthB=widthB, lengthB=lengthB, angleB=angleB)\n\n _style_list[\"-[\"] = BracketB\n\n class BarAB(_Bracket):\n \"\"\"\n An arrow with a bar(|) at both ends.\n \"\"\"\n\n def __init__(self,\n widthA=1., angleA=None,\n widthB=1., angleB=None):\n \"\"\"\n *widthA*\n width of the bracket\n\n *lengthA*\n length of the bracket\n\n *angleA*\n angle between the bracket and the line\n\n *widthB*\n width of the bracket\n\n *lengthB*\n length of the bracket\n\n *angleB*\n angle between the bracket and the line\n \"\"\"\n\n super(ArrowStyle.BarAB, self).__init__(\n True, True, widthA=widthA, lengthA=0, angleA=angleA,\n widthB=widthB, lengthB=0, angleB=angleB)\n\n _style_list[\"|-|\"] = BarAB\n\n class Simple(_Base):\n \"\"\"\n A simple arrow. Only works with a quadratic bezier curve.\n \"\"\"\n\n def __init__(self, head_length=.5, head_width=.5, tail_width=.2):\n \"\"\"\n *head_length*\n length of the arrow head\n\n *head_with*\n width of the arrow head\n\n *tail_width*\n width of the arrow tail\n\n \"\"\"\n\n self.head_length, self.head_width, self.tail_width = \\\n head_length, head_width, tail_width\n super(ArrowStyle.Simple, self).__init__()\n\n def transmute(self, path, mutation_size, linewidth):\n\n x0, y0, x1, y1, x2, y2 = self.ensure_quadratic_bezier(path)\n\n # divide the path into a head and a tail\n head_length = self.head_length * mutation_size\n in_f = inside_circle(x2, y2, head_length)\n arrow_path = [(x0, y0), (x1, y1), (x2, y2)]\n\n from .bezier import NonIntersectingPathException\n\n try:\n arrow_out, arrow_in = \\\n split_bezier_intersecting_with_closedpath(arrow_path,\n in_f,\n tolerence=0.01)\n except NonIntersectingPathException:\n # if this happens, make a straight line of the head_length\n # long.\n x0, y0 = _point_along_a_line(x2, y2, x1, y1, head_length)\n x1n, y1n = 0.5 * (x0 + x2), 0.5 * (y0 + y2)\n arrow_in = [(x0, y0), (x1n, y1n), (x2, y2)]\n arrow_out = None\n\n # head\n head_width = self.head_width * mutation_size\n head_left, head_right = \\\n make_wedged_bezier2(arrow_in, head_width / 2.,\n wm=.5)\n\n # tail\n if arrow_out is not None:\n tail_width = self.tail_width * mutation_size\n tail_left, tail_right = get_parallels(arrow_out,\n tail_width / 2.)\n\n #head_right, head_left = head_r, head_l\n patch_path = [(Path.MOVETO, tail_right[0]),\n (Path.CURVE3, tail_right[1]),\n (Path.CURVE3, tail_right[2]),\n (Path.LINETO, head_right[0]),\n (Path.CURVE3, head_right[1]),\n (Path.CURVE3, head_right[2]),\n (Path.CURVE3, head_left[1]),\n (Path.CURVE3, head_left[0]),\n (Path.LINETO, tail_left[2]),\n (Path.CURVE3, tail_left[1]),\n (Path.CURVE3, tail_left[0]),\n (Path.LINETO, tail_right[0]),\n (Path.CLOSEPOLY, tail_right[0]),\n ]\n else:\n patch_path = [(Path.MOVETO, head_right[0]),\n (Path.CURVE3, head_right[1]),\n (Path.CURVE3, head_right[2]),\n (Path.CURVE3, head_left[1]),\n (Path.CURVE3, head_left[0]),\n (Path.CLOSEPOLY, head_left[0]),\n ]\n\n path = Path([p for c, p in patch_path], [c for c, p in patch_path])\n\n return path, True\n\n _style_list[\"simple\"] = Simple\n\n class Fancy(_Base):\n \"\"\"\n A fancy arrow. Only works with a quadratic bezier curve.\n \"\"\"\n\n def __init__(self, head_length=.4, head_width=.4, tail_width=.4):\n \"\"\"\n *head_length*\n length of the arrow head\n\n *head_with*\n width of the arrow head\n\n *tail_width*\n width of the arrow tail\n\n \"\"\"\n\n self.head_length, self.head_width, self.tail_width = \\\n head_length, head_width, tail_width\n super(ArrowStyle.Fancy, self).__init__()\n\n def transmute(self, path, mutation_size, linewidth):\n\n x0, y0, x1, y1, x2, y2 = self.ensure_quadratic_bezier(path)\n\n # divide the path into a head and a tail\n head_length = self.head_length * mutation_size\n arrow_path = [(x0, y0), (x1, y1), (x2, y2)]\n\n from .bezier import NonIntersectingPathException\n\n # path for head\n in_f = inside_circle(x2, y2, head_length)\n try:\n path_out, path_in = \\\n split_bezier_intersecting_with_closedpath(\n arrow_path,\n in_f,\n tolerence=0.01)\n except NonIntersectingPathException:\n # if this happens, make a straight line of the head_length\n # long.\n x0, y0 = _point_along_a_line(x2, y2, x1, y1, head_length)\n x1n, y1n = 0.5 * (x0 + x2), 0.5 * (y0 + y2)\n arrow_path = [(x0, y0), (x1n, y1n), (x2, y2)]\n path_head = arrow_path\n else:\n path_head = path_in\n\n # path for head\n in_f = inside_circle(x2, y2, head_length * .8)\n path_out, path_in = \\\n split_bezier_intersecting_with_closedpath(\n arrow_path,\n in_f,\n tolerence=0.01)\n path_tail = path_out\n\n # head\n head_width = self.head_width * mutation_size\n head_l, head_r = make_wedged_bezier2(path_head,\n head_width / 2.,\n wm=.6)\n\n # tail\n tail_width = self.tail_width * mutation_size\n tail_left, tail_right = make_wedged_bezier2(path_tail,\n tail_width * .5,\n w1=1., wm=0.6, w2=0.3)\n\n # path for head\n in_f = inside_circle(x0, y0, tail_width * .3)\n path_in, path_out = \\\n split_bezier_intersecting_with_closedpath(\n arrow_path,\n in_f,\n tolerence=0.01)\n tail_start = path_in[-1]\n\n head_right, head_left = head_r, head_l\n patch_path = [(Path.MOVETO, tail_start),\n (Path.LINETO, tail_right[0]),\n (Path.CURVE3, tail_right[1]),\n (Path.CURVE3, tail_right[2]),\n (Path.LINETO, head_right[0]),\n (Path.CURVE3, head_right[1]),\n (Path.CURVE3, head_right[2]),\n (Path.CURVE3, head_left[1]),\n (Path.CURVE3, head_left[0]),\n (Path.LINETO, tail_left[2]),\n (Path.CURVE3, tail_left[1]),\n (Path.CURVE3, tail_left[0]),\n (Path.LINETO, tail_start),\n (Path.CLOSEPOLY, tail_start),\n ]\n path = Path([p for c, p in patch_path], [c for c, p in patch_path])\n\n return path, True\n\n _style_list[\"fancy\"] = Fancy\n\n class Wedge(_Base):\n \"\"\"\n Wedge(?) shape. Only wokrs with a quadratic bezier curve. The\n begin point has a width of the tail_width and the end point has a\n width of 0. At the middle, the width is shrink_factor*tail_width.\n\n \"\"\"\n\n def __init__(self, tail_width=.3, shrink_factor=0.5):\n \"\"\"\n *tail_width*\n width of the tail\n\n *shrink_factor*\n fraction of the arrow width at the middle point\n \"\"\"\n\n self.tail_width = tail_width\n self.shrink_factor = shrink_factor\n super(ArrowStyle.Wedge, self).__init__()\n\n def transmute(self, path, mutation_size, linewidth):\n\n x0, y0, x1, y1, x2, y2 = self.ensure_quadratic_bezier(path)\n\n arrow_path = [(x0, y0), (x1, y1), (x2, y2)]\n b_plus, b_minus = make_wedged_bezier2(\n arrow_path,\n self.tail_width * mutation_size / 2.,\n wm=self.shrink_factor)\n\n patch_path = [(Path.MOVETO, b_plus[0]),\n (Path.CURVE3, b_plus[1]),\n (Path.CURVE3, b_plus[2]),\n (Path.LINETO, b_minus[2]),\n (Path.CURVE3, b_minus[1]),\n (Path.CURVE3, b_minus[0]),\n (Path.CLOSEPOLY, b_minus[0]),\n ]\n path = Path([p for c, p in patch_path], [c for c, p in patch_path])\n\n return path, True\n\n _style_list[\"wedge\"] = Wedge\n\n if __doc__:\n __doc__ = cbook.dedent(__doc__) % \\\n {\"AvailableArrowstyles\": _pprint_styles(_style_list)}\n\n\ndocstring.interpd.update(\n AvailableArrowstyles=_pprint_styles(ArrowStyle._style_list),\n AvailableConnectorstyles=_pprint_styles(ConnectionStyle._style_list),\n)\n\n\nclass FancyArrowPatch(Patch):\n \"\"\"\n A fancy arrow patch. It draws an arrow using the :class:ArrowStyle.\n \"\"\"\n\n def __str__(self):\n\n if self._posA_posB is not None:\n (x1, y1), (x2, y2) = self._posA_posB\n return self.__class__.__name__ \\\n + \"(%g,%g->%g,%g)\" % (x1, y1, x2, y2)\n else:\n return self.__class__.__name__ \\\n + \"(%s)\" % (str(self._path_original),)\n\n @docstring.dedent_interpd\n def __init__(self, posA=None, posB=None,\n path=None,\n arrowstyle=\"simple\",\n arrow_transmuter=None,\n connectionstyle=\"arc3\",\n connector=None,\n patchA=None,\n patchB=None,\n shrinkA=2.,\n shrinkB=2.,\n mutation_scale=1.,\n mutation_aspect=None,\n dpi_cor=1.,\n **kwargs):\n \"\"\"\n If *posA* and *posB* is given, a path connecting two point are\n created according to the connectionstyle. The path will be\n clipped with *patchA* and *patchB* and further shirnked by\n *shrinkA* and *shrinkB*. An arrow is drawn along this\n resulting path using the *arrowstyle* parameter. If *path*\n provided, an arrow is drawn along this path and *patchA*,\n *patchB*, *shrinkA*, and *shrinkB* are ignored.\n\n The *connectionstyle* describes how *posA* and *posB* are\n connected. It can be an instance of the ConnectionStyle class\n (matplotlib.patches.ConnectionStlye) or a string of the\n connectionstyle name, with optional comma-separated\n attributes. The following connection styles are available.\n\n %(AvailableConnectorstyles)s\n\n\n The *arrowstyle* describes how the fancy arrow will be\n drawn. It can be string of the available arrowstyle names,\n with optional comma-separated attributes, or one of the\n ArrowStyle instance. The optional attributes are meant to be\n scaled with the *mutation_scale*. The following arrow styles are\n available.\n\n %(AvailableArrowstyles)s\n\n *mutation_scale* : a value with which attributes of arrowstyle\n (e.g., head_length) will be scaled. default=1.\n\n *mutation_aspect* : The height of the rectangle will be\n squeezed by this value before the mutation and the mutated\n box will be stretched by the inverse of it. default=None.\n\n Valid kwargs are:\n %(Patch)s\n \"\"\"\n\n if posA is not None and posB is not None and path is None:\n self._posA_posB = [posA, posB]\n\n if connectionstyle is None:\n connectionstyle = \"arc3\"\n self.set_connectionstyle(connectionstyle)\n\n elif posA is None and posB is None and path is not None:\n self._posA_posB = None\n self._connetors = None\n else:\n raise ValueError(\"either posA and posB, or path need to provided\")\n\n self.patchA = patchA\n self.patchB = patchB\n self.shrinkA = shrinkA\n self.shrinkB = shrinkB\n\n Patch.__init__(self, **kwargs)\n\n self._path_original = path\n\n self.set_arrowstyle(arrowstyle)\n\n self._mutation_scale = mutation_scale\n self._mutation_aspect = mutation_aspect\n\n self.set_dpi_cor(dpi_cor)\n #self._draw_in_display_coordinate = True\n\n def set_dpi_cor(self, dpi_cor):\n \"\"\"\n dpi_cor is currently used for linewidth-related things and\n shink factor. Mutation scale is not affected by this.\n \"\"\"\n\n self._dpi_cor = dpi_cor\n\n def get_dpi_cor(self):\n \"\"\"\n dpi_cor is currently used for linewidth-related things and\n shink factor. Mutation scale is not affected by this.\n \"\"\"\n\n return self._dpi_cor\n\n def set_positions(self, posA, posB):\n \"\"\" set the begin end end positions of the connecting\n path. Use current vlaue if None.\n \"\"\"\n if posA is not None:\n self._posA_posB[0] = posA\n if posB is not None:\n self._posA_posB[1] = posB\n\n def set_patchA(self, patchA):\n \"\"\" set the begin patch.\n \"\"\"\n self.patchA = patchA\n\n def set_patchB(self, patchB):\n \"\"\" set the begin patch\n \"\"\"\n self.patchB = patchB\n\n def set_connectionstyle(self, connectionstyle, **kw):\n \"\"\"\n Set the connection style.\n\n *connectionstyle* can be a string with connectionstyle name with\n optional comma-separated attributes. Alternatively, the attrs can be\n probided as keywords.\n\n set_connectionstyle(\"arc,angleA=0,armA=30,rad=10\")\n set_connectionstyle(\"arc\", angleA=0,armA=30,rad=10)\n\n Old attrs simply are forgotten.\n\n Without argument (or with connectionstyle=None), return\n available styles as a list of strings.\n \"\"\"\n\n if connectionstyle is None:\n return ConnectionStyle.pprint_styles()\n\n if isinstance(connectionstyle, ConnectionStyle._Base):\n self._connector = connectionstyle\n elif six.callable(connectionstyle):\n # we may need check the calling convention of the given function\n self._connector = connectionstyle\n else:\n self._connector = ConnectionStyle(connectionstyle, **kw)\n\n def get_connectionstyle(self):\n \"\"\"\n Return the ConnectionStyle instance\n \"\"\"\n return self._connector\n\n def set_arrowstyle(self, arrowstyle=None, **kw):\n \"\"\"\n Set the arrow style.\n\n *arrowstyle* can be a string with arrowstyle name with optional\n comma-separated attributes. Alternatively, the attrs can\n be provided as keywords.\n\n set_arrowstyle(\"Fancy,head_length=0.2\")\n set_arrowstyle(\"fancy\", head_length=0.2)\n\n Old attrs simply are forgotten.\n\n Without argument (or with arrowstyle=None), return\n available box styles as a list of strings.\n \"\"\"\n\n if arrowstyle is None:\n return ArrowStyle.pprint_styles()\n\n if isinstance(arrowstyle, ArrowStyle._Base):\n self._arrow_transmuter = arrowstyle\n else:\n self._arrow_transmuter = ArrowStyle(arrowstyle, **kw)\n\n def get_arrowstyle(self):\n \"\"\"\n Return the arrowstyle object\n \"\"\"\n return self._arrow_transmuter\n\n def set_mutation_scale(self, scale):\n \"\"\"\n Set the mutation scale.\n\n ACCEPTS: float\n \"\"\"\n self._mutation_scale = scale\n\n def get_mutation_scale(self):\n \"\"\"\n Return the mutation scale.\n \"\"\"\n return self._mutation_scale\n\n def set_mutation_aspect(self, aspect):\n \"\"\"\n Set the aspect ratio of the bbox mutation.\n\n ACCEPTS: float\n \"\"\"\n self._mutation_aspect = aspect\n\n def get_mutation_aspect(self):\n \"\"\"\n Return the aspect ratio of the bbox mutation.\n \"\"\"\n return self._mutation_aspect\n\n def get_path(self):\n \"\"\"\n return the path of the arrow in the data coordinate. Use\n get_path_in_displaycoord() method to retrieve the arrow path\n in the display coord.\n \"\"\"\n _path, fillable = self.get_path_in_displaycoord()\n\n if cbook.iterable(fillable):\n _path = concatenate_paths(_path)\n\n return self.get_transform().inverted().transform_path(_path)\n\n def get_path_in_displaycoord(self):\n \"\"\"\n Return the mutated path of the arrow in the display coord\n \"\"\"\n\n dpi_cor = self.get_dpi_cor()\n\n if self._posA_posB is not None:\n posA = self.get_transform().transform_point(self._posA_posB[0])\n posB = self.get_transform().transform_point(self._posA_posB[1])\n _path = self.get_connectionstyle()(posA, posB,\n patchA=self.patchA,\n patchB=self.patchB,\n shrinkA=self.shrinkA * dpi_cor,\n shrinkB=self.shrinkB * dpi_cor\n )\n else:\n _path = self.get_transform().transform_path(self._path_original)\n\n _path, fillable = self.get_arrowstyle()(_path,\n self.get_mutation_scale(),\n self.get_linewidth() * dpi_cor,\n self.get_mutation_aspect()\n )\n\n #if not fillable:\n # self._fill = False\n\n return _path, fillable\n\n def draw(self, renderer):\n if not self.get_visible():\n return\n\n renderer.open_group('patch', self.get_gid())\n gc = renderer.new_gc()\n\n gc.set_foreground(self._edgecolor, isRGBA=True)\n\n lw = self._linewidth\n if self._edgecolor[3] == 0:\n lw = 0\n gc.set_linewidth(lw)\n gc.set_linestyle(self._linestyle)\n\n gc.set_antialiased(self._antialiased)\n self._set_gc_clip(gc)\n gc.set_capstyle('round')\n gc.set_snap(self.get_snap())\n\n rgbFace = self._facecolor\n if rgbFace[3] == 0:\n rgbFace = None # (some?) renderers expect this as no-fill signal\n\n gc.set_alpha(self._alpha)\n\n if self._hatch:\n gc.set_hatch(self._hatch)\n\n if self.get_sketch_params() is not None:\n gc.set_sketch_params(*self.get_sketch_params())\n\n # FIXME : dpi_cor is for the dpi-dependecy of the\n # linewidth. There could be room for improvement.\n #\n #dpi_cor = renderer.points_to_pixels(1.)\n self.set_dpi_cor(renderer.points_to_pixels(1.))\n path, fillable = self.get_path_in_displaycoord()\n\n if not cbook.iterable(fillable):\n path = [path]\n fillable = [fillable]\n\n affine = transforms.IdentityTransform()\n\n if self.get_path_effects():\n from matplotlib.patheffects import PathEffectRenderer\n renderer = PathEffectRenderer(self.get_path_effects(), renderer)\n\n for p, f in zip(path, fillable):\n if f:\n renderer.draw_path(gc, p, affine, rgbFace)\n else:\n renderer.draw_path(gc, p, affine, None)\n\n gc.restore()\n renderer.close_group('patch')\n\n\nclass ConnectionPatch(FancyArrowPatch):\n \"\"\"\n A :class:`~matplotlib.patches.ConnectionPatch` class is to make\n connecting lines between two points (possibly in different axes).\n \"\"\"\n def __str__(self):\n return \"ConnectionPatch((%g,%g),(%g,%g))\" % \\\n (self.xy1[0], self.xy1[1], self.xy2[0], self.xy2[1])\n\n @docstring.dedent_interpd\n def __init__(self, xyA, xyB, coordsA, coordsB=None,\n axesA=None, axesB=None,\n arrowstyle=\"-\",\n arrow_transmuter=None,\n connectionstyle=\"arc3\",\n connector=None,\n patchA=None,\n patchB=None,\n shrinkA=0.,\n shrinkB=0.,\n mutation_scale=10.,\n mutation_aspect=None,\n clip_on=False,\n dpi_cor=1.,\n **kwargs):\n \"\"\"\n Connect point *xyA* in *coordsA* with point *xyB* in *coordsB*\n\n\n Valid keys are\n\n\n =============== ======================================================\n Key Description\n =============== ======================================================\n arrowstyle the arrow style\n connectionstyle the connection style\n relpos default is (0.5, 0.5)\n patchA default is bounding box of the text\n patchB default is None\n shrinkA default is 2 points\n shrinkB default is 2 points\n mutation_scale default is text size (in points)\n mutation_aspect default is 1.\n ? any key for :class:`matplotlib.patches.PathPatch`\n =============== ======================================================\n\n\n *coordsA* and *coordsB* are strings that indicate the\n coordinates of *xyA* and *xyB*.\n\n ================= ===================================================\n Property Description\n ================= ===================================================\n 'figure points' points from the lower left corner of the figure\n 'figure pixels' pixels from the lower left corner of the figure\n 'figure fraction' 0,0 is lower left of figure and 1,1 is upper, right\n 'axes points' points from lower left corner of axes\n 'axes pixels' pixels from lower left corner of axes\n 'axes fraction' 0,1 is lower left of axes and 1,1 is upper right\n 'data' use the coordinate system of the object being\n annotated (default)\n 'offset points' Specify an offset (in points) from the *xy* value\n\n 'polar' you can specify *theta*, *r* for the annotation,\n even in cartesian plots. Note that if you\n are using a polar axes, you do not need\n to specify polar for the coordinate\n system since that is the native \"data\" coordinate\n system.\n ================= ===================================================\n\n \"\"\"\n if coordsB is None:\n coordsB = coordsA\n # we'll draw ourself after the artist we annotate by default\n self.xy1 = xyA\n self.xy2 = xyB\n self.coords1 = coordsA\n self.coords2 = coordsB\n\n self.axesA = axesA\n self.axesB = axesB\n\n FancyArrowPatch.__init__(self,\n posA=(0, 0), posB=(1, 1),\n arrowstyle=arrowstyle,\n arrow_transmuter=arrow_transmuter,\n connectionstyle=connectionstyle,\n connector=connector,\n patchA=patchA,\n patchB=patchB,\n shrinkA=shrinkA,\n shrinkB=shrinkB,\n mutation_scale=mutation_scale,\n mutation_aspect=mutation_aspect,\n clip_on=clip_on,\n dpi_cor=dpi_cor,\n **kwargs)\n\n # if True, draw annotation only if self.xy is inside the axes\n self._annotation_clip = None\n\n def _get_xy(self, x, y, s, axes=None):\n \"\"\"\n caculate the pixel position of given point\n \"\"\"\n\n if axes is None:\n axes = self.axes\n\n if s == 'data':\n trans = axes.transData\n x = float(self.convert_xunits(x))\n y = float(self.convert_yunits(y))\n return trans.transform_point((x, y))\n elif s == 'offset points':\n # convert the data point\n dx, dy = self.xy\n\n # prevent recursion\n if self.xycoords == 'offset points':\n return self._get_xy(dx, dy, 'data')\n\n dx, dy = self._get_xy(dx, dy, self.xycoords)\n\n # convert the offset\n dpi = self.figure.get_dpi()\n x *= dpi / 72.\n y *= dpi / 72.\n\n # add the offset to the data point\n x += dx\n y += dy\n\n return x, y\n elif s == 'polar':\n theta, r = x, y\n x = r * np.cos(theta)\n y = r * np.sin(theta)\n trans = axes.transData\n return trans.transform_point((x, y))\n elif s == 'figure points':\n # points from the lower left corner of the figure\n dpi = self.figure.dpi\n l, b, w, h = self.figure.bbox.bounds\n r = l + w\n t = b + h\n\n x *= dpi / 72.\n y *= dpi / 72.\n if x < 0:\n x = r + x\n if y < 0:\n y = t + y\n return x, y\n elif s == 'figure pixels':\n # pixels from the lower left corner of the figure\n l, b, w, h = self.figure.bbox.bounds\n r = l + w\n t = b + h\n if x < 0:\n x = r + x\n if y < 0:\n y = t + y\n return x, y\n elif s == 'figure fraction':\n # (0,0) is lower left, (1,1) is upper right of figure\n trans = self.figure.transFigure\n return trans.transform_point((x, y))\n elif s == 'axes points':\n # points from the lower left corner of the axes\n dpi = self.figure.dpi\n l, b, w, h = axes.bbox.bounds\n r = l + w\n t = b + h\n if x < 0:\n x = r + x * dpi / 72.\n else:\n x = l + x * dpi / 72.\n if y < 0:\n y = t + y * dpi / 72.\n else:\n y = b + y * dpi / 72.\n return x, y\n elif s == 'axes pixels':\n #pixels from the lower left corner of the axes\n\n l, b, w, h = axes.bbox.bounds\n r = l + w\n t = b + h\n if x < 0:\n x = r + x\n else:\n x = l + x\n if y < 0:\n y = t + y\n else:\n y = b + y\n return x, y\n elif s == 'axes fraction':\n #(0,0) is lower left, (1,1) is upper right of axes\n trans = axes.transAxes\n return trans.transform_point((x, y))\n\n def set_annotation_clip(self, b):\n \"\"\"\n set *annotation_clip* attribute.\n\n * True: the annotation will only be drawn when self.xy is inside the\n axes.\n * False: the annotation will always be drawn regardless of its\n position.\n * None: the self.xy will be checked only if *xycoords* is \"data\"\n \"\"\"\n self._annotation_clip = b\n\n def get_annotation_clip(self):\n \"\"\"\n Return *annotation_clip* attribute.\n See :meth:`set_annotation_clip` for the meaning of return values.\n \"\"\"\n return self._annotation_clip\n\n def get_path_in_displaycoord(self):\n \"\"\"\n Return the mutated path of the arrow in the display coord\n \"\"\"\n\n dpi_cor = self.get_dpi_cor()\n\n x, y = self.xy1\n posA = self._get_xy(x, y, self.coords1, self.axesA)\n\n x, y = self.xy2\n posB = self._get_xy(x, y, self.coords2, self.axesB)\n\n _path = self.get_connectionstyle()(posA, posB,\n patchA=self.patchA,\n patchB=self.patchB,\n shrinkA=self.shrinkA * dpi_cor,\n shrinkB=self.shrinkB * dpi_cor\n )\n\n _path, fillable = self.get_arrowstyle()(_path,\n self.get_mutation_scale(),\n self.get_linewidth() * dpi_cor,\n self.get_mutation_aspect()\n )\n\n return _path, fillable\n\n def _check_xy(self, renderer):\n \"\"\"\n check if the annotation need to\n be drawn.\n \"\"\"\n\n b = self.get_annotation_clip()\n\n if b or (b is None and self.coords1 == \"data\"):\n x, y = self.xy1\n xy_pixel = self._get_xy(x, y, self.coords1, self.axesA)\n if not self.axes.contains_point(xy_pixel):\n return False\n\n if b or (b is None and self.coords2 == \"data\"):\n x, y = self.xy2\n xy_pixel = self._get_xy(x, y, self.coords2, self.axesB)\n if self.axesB is None:\n axes = self.axes\n else:\n axes = self.axesB\n if not axes.contains_point(xy_pixel):\n return False\n\n return True\n\n def draw(self, renderer):\n \"\"\"\n Draw.\n \"\"\"\n\n if renderer is not None:\n self._renderer = renderer\n if not self.get_visible():\n return\n\n if not self._check_xy(renderer):\n return\n\n FancyArrowPatch.draw(self, renderer)\n",
"\"\"\"\nA module providing some utility functions regarding bezier path manipulation.\n\"\"\"\n\nfrom __future__ import (absolute_import, division, print_function,\n unicode_literals)\n\nimport six\n\nimport numpy as np\nfrom matplotlib.path import Path\n\nfrom operator import xor\nimport warnings\n\n\nclass NonIntersectingPathException(ValueError):\n pass\n\n# some functions\n\n\ndef get_intersection(cx1, cy1, cos_t1, sin_t1,\n cx2, cy2, cos_t2, sin_t2):\n \"\"\" return a intersecting point between a line through (cx1, cy1)\n and having angle t1 and a line through (cx2, cy2) and angle t2.\n \"\"\"\n\n # line1 => sin_t1 * (x - cx1) - cos_t1 * (y - cy1) = 0.\n # line1 => sin_t1 * x + cos_t1 * y = sin_t1*cx1 - cos_t1*cy1\n\n line1_rhs = sin_t1 * cx1 - cos_t1 * cy1\n line2_rhs = sin_t2 * cx2 - cos_t2 * cy2\n\n # rhs matrix\n a, b = sin_t1, -cos_t1\n c, d = sin_t2, -cos_t2\n\n ad_bc = a * d - b * c\n if ad_bc == 0.:\n raise ValueError(\"Given lines do not intersect\")\n\n #rhs_inverse\n a_, b_ = d, -b\n c_, d_ = -c, a\n a_, b_, c_, d_ = [k / ad_bc for k in [a_, b_, c_, d_]]\n\n x = a_ * line1_rhs + b_ * line2_rhs\n y = c_ * line1_rhs + d_ * line2_rhs\n\n return x, y\n\n\ndef get_normal_points(cx, cy, cos_t, sin_t, length):\n \"\"\"\n For a line passing through (*cx*, *cy*) and having a angle *t*, return\n locations of the two points located along its perpendicular line at the\n distance of *length*.\n \"\"\"\n\n if length == 0.:\n return cx, cy, cx, cy\n\n cos_t1, sin_t1 = sin_t, -cos_t\n cos_t2, sin_t2 = -sin_t, cos_t\n\n x1, y1 = length * cos_t1 + cx, length * sin_t1 + cy\n x2, y2 = length * cos_t2 + cx, length * sin_t2 + cy\n\n return x1, y1, x2, y2\n\n\n## BEZIER routines\n\n# subdividing bezier curve\n# http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/Bezier/bezier-sub.html\n\n\ndef _de_casteljau1(beta, t):\n next_beta = beta[:-1] * (1 - t) + beta[1:] * t\n return next_beta\n\n\ndef split_de_casteljau(beta, t):\n \"\"\"split a bezier segment defined by its controlpoints *beta*\n into two separate segment divided at *t* and return their control points.\n\n \"\"\"\n beta = np.asarray(beta)\n beta_list = [beta]\n while True:\n beta = _de_casteljau1(beta, t)\n beta_list.append(beta)\n if len(beta) == 1:\n break\n left_beta = [beta[0] for beta in beta_list]\n right_beta = [beta[-1] for beta in reversed(beta_list)]\n\n return left_beta, right_beta\n\n\n# FIXME spelling mistake in the name of the parameter ``tolerence``\ndef find_bezier_t_intersecting_with_closedpath(bezier_point_at_t,\n inside_closedpath,\n t0=0., t1=1., tolerence=0.01):\n \"\"\" Find a parameter t0 and t1 of the given bezier path which\n bounds the intersecting points with a provided closed\n path(*inside_closedpath*). Search starts from *t0* and *t1* and it\n uses a simple bisecting algorithm therefore one of the end point\n must be inside the path while the orther doesn't. The search stop\n when |t0-t1| gets smaller than the given tolerence.\n value for\n\n - bezier_point_at_t : a function which returns x, y coordinates at *t*\n\n - inside_closedpath : return True if the point is insed the path\n\n \"\"\"\n # inside_closedpath : function\n\n start = bezier_point_at_t(t0)\n end = bezier_point_at_t(t1)\n\n start_inside = inside_closedpath(start)\n end_inside = inside_closedpath(end)\n\n if not xor(start_inside, end_inside):\n raise NonIntersectingPathException(\n \"the segment does not seem to intersect with the path\")\n\n while 1:\n\n # return if the distance is smaller than the tolerence\n if (start[0] - end[0]) ** 2 + \\\n (start[1] - end[1]) ** 2 < tolerence ** 2:\n return t0, t1\n\n # calculate the middle point\n middle_t = 0.5 * (t0 + t1)\n middle = bezier_point_at_t(middle_t)\n middle_inside = inside_closedpath(middle)\n\n if xor(start_inside, middle_inside):\n t1 = middle_t\n end = middle\n end_inside = middle_inside\n else:\n t0 = middle_t\n start = middle\n start_inside = middle_inside\n\n\nclass BezierSegment(object):\n \"\"\"\n A simple class of a 2-dimensional bezier segment\n \"\"\"\n\n # Higher order bezier lines can be supported by simplying adding\n # corresponding values.\n _binom_coeff = {1: np.array([1., 1.]),\n 2: np.array([1., 2., 1.]),\n 3: np.array([1., 3., 3., 1.])}\n\n def __init__(self, control_points):\n \"\"\"\n *control_points* : location of contol points. It needs have a\n shpae of n * 2, where n is the order of the bezier line. 1<=\n n <= 3 is supported.\n \"\"\"\n _o = len(control_points)\n self._orders = np.arange(_o)\n _coeff = BezierSegment._binom_coeff[_o - 1]\n\n _control_points = np.asarray(control_points)\n xx = _control_points[:, 0]\n yy = _control_points[:, 1]\n\n self._px = xx * _coeff\n self._py = yy * _coeff\n\n def point_at_t(self, t):\n \"evaluate a point at t\"\n one_minus_t_powers = np.power(1. - t, self._orders)[::-1]\n t_powers = np.power(t, self._orders)\n\n tt = one_minus_t_powers * t_powers\n _x = sum(tt * self._px)\n _y = sum(tt * self._py)\n\n return _x, _y\n\n\ndef split_bezier_intersecting_with_closedpath(bezier,\n inside_closedpath,\n tolerence=0.01):\n\n \"\"\"\n bezier : control points of the bezier segment\n inside_closedpath : a function which returns true if the point is inside\n the path\n \"\"\"\n\n bz = BezierSegment(bezier)\n bezier_point_at_t = bz.point_at_t\n\n t0, t1 = find_bezier_t_intersecting_with_closedpath(bezier_point_at_t,\n inside_closedpath,\n tolerence=tolerence)\n\n _left, _right = split_de_casteljau(bezier, (t0 + t1) / 2.)\n return _left, _right\n\n\ndef find_r_to_boundary_of_closedpath(inside_closedpath, xy,\n cos_t, sin_t,\n rmin=0., rmax=1., tolerence=0.01):\n \"\"\"\n Find a radius r (centered at *xy*) between *rmin* and *rmax* at\n which it intersect with the path.\n\n inside_closedpath : function\n cx, cy : center\n cos_t, sin_t : cosine and sine for the angle\n rmin, rmax :\n \"\"\"\n\n cx, cy = xy\n\n def _f(r):\n return cos_t * r + cx, sin_t * r + cy\n\n find_bezier_t_intersecting_with_closedpath(_f, inside_closedpath,\n t0=rmin, t1=rmax,\n tolerence=tolerence)\n\n## matplotlib specific\n\n\ndef split_path_inout(path, inside, tolerence=0.01, reorder_inout=False):\n \"\"\" divide a path into two segment at the point where inside(x, y)\n becomes False.\n \"\"\"\n\n path_iter = path.iter_segments()\n\n ctl_points, command = next(path_iter)\n begin_inside = inside(ctl_points[-2:]) # true if begin point is inside\n\n bezier_path = None\n ctl_points_old = ctl_points\n\n concat = np.concatenate\n\n iold = 0\n i = 1\n\n for ctl_points, command in path_iter:\n iold = i\n i += len(ctl_points) / 2\n if inside(ctl_points[-2:]) != begin_inside:\n bezier_path = concat([ctl_points_old[-2:], ctl_points])\n break\n\n ctl_points_old = ctl_points\n\n if bezier_path is None:\n raise ValueError(\"The path does not seem to intersect with the patch\")\n\n bp = list(zip(bezier_path[::2], bezier_path[1::2]))\n left, right = split_bezier_intersecting_with_closedpath(bp,\n inside,\n tolerence)\n if len(left) == 2:\n codes_left = [Path.LINETO]\n codes_right = [Path.MOVETO, Path.LINETO]\n elif len(left) == 3:\n codes_left = [Path.CURVE3, Path.CURVE3]\n codes_right = [Path.MOVETO, Path.CURVE3, Path.CURVE3]\n elif len(left) == 4:\n codes_left = [Path.CURVE4, Path.CURVE4, Path.CURVE4]\n codes_right = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]\n else:\n raise ValueError()\n\n verts_left = left[1:]\n verts_right = right[:]\n\n #i += 1\n\n if path.codes is None:\n path_in = Path(concat([path.vertices[:i], verts_left]))\n path_out = Path(concat([verts_right, path.vertices[i:]]))\n\n else:\n path_in = Path(concat([path.vertices[:iold], verts_left]),\n concat([path.codes[:iold], codes_left]))\n\n path_out = Path(concat([verts_right, path.vertices[i:]]),\n concat([codes_right, path.codes[i:]]))\n\n if reorder_inout and begin_inside == False:\n path_in, path_out = path_out, path_in\n\n return path_in, path_out\n\n\ndef inside_circle(cx, cy, r):\n r2 = r ** 2\n\n def _f(xy):\n x, y = xy\n return (x - cx) ** 2 + (y - cy) ** 2 < r2\n return _f\n\n\n# quadratic bezier lines\n\ndef get_cos_sin(x0, y0, x1, y1):\n dx, dy = x1 - x0, y1 - y0\n d = (dx * dx + dy * dy) ** .5\n return dx / d, dy / d\n\n\ndef check_if_parallel(dx1, dy1, dx2, dy2, tolerence=1.e-5):\n \"\"\" returns\n * 1 if two lines are parralel in same direction\n * -1 if two lines are parralel in opposite direction\n * 0 otherwise\n \"\"\"\n theta1 = np.arctan2(dx1, dy1)\n theta2 = np.arctan2(dx2, dy2)\n dtheta = np.abs(theta1 - theta2)\n if dtheta < tolerence:\n return 1\n elif np.abs(dtheta - np.pi) < tolerence:\n return -1\n else:\n return False\n\n\ndef get_parallels(bezier2, width):\n \"\"\"\n Given the quadratic bezier control points *bezier2*, returns\n control points of quadratic bezier lines roughly parallel to given\n one separated by *width*.\n \"\"\"\n\n # The parallel bezier lines are constructed by following ways.\n # c1 and c2 are contol points representing the begin and end of the\n # bezier line.\n # cm is the middle point\n\n c1x, c1y = bezier2[0]\n cmx, cmy = bezier2[1]\n c2x, c2y = bezier2[2]\n\n parallel_test = check_if_parallel(c1x - cmx, c1y - cmy,\n cmx - c2x, cmy - c2y)\n\n if parallel_test == -1:\n warnings.warn(\n \"Lines do not intersect. A straight line is used instead.\")\n #cmx, cmy = 0.5*(c1x+c2x), 0.5*(c1y+c2y)\n cos_t1, sin_t1 = get_cos_sin(c1x, c1y, c2x, c2y)\n cos_t2, sin_t2 = cos_t1, sin_t1\n else:\n # t1 and t2 is the angle between c1 and cm, cm, c2. They are\n # also a angle of the tangential line of the path at c1 and c2\n cos_t1, sin_t1 = get_cos_sin(c1x, c1y, cmx, cmy)\n cos_t2, sin_t2 = get_cos_sin(cmx, cmy, c2x, c2y)\n\n # find c1_left, c1_right which are located along the lines\n # throught c1 and perpendicular to the tangential lines of the\n # bezier path at a distance of width. Same thing for c2_left and\n # c2_right with respect to c2.\n c1x_left, c1y_left, c1x_right, c1y_right = \\\n get_normal_points(c1x, c1y, cos_t1, sin_t1, width)\n c2x_left, c2y_left, c2x_right, c2y_right = \\\n get_normal_points(c2x, c2y, cos_t2, sin_t2, width)\n\n # find cm_left which is the intersectng point of a line through\n # c1_left with angle t1 and a line throught c2_left with angle\n # t2. Same with cm_right.\n if parallel_test != 0:\n # a special case for a straight line, i.e., angle between two\n # lines are smaller than some (arbitrtay) value.\n cmx_left, cmy_left = \\\n 0.5 * (c1x_left + c2x_left), 0.5 * (c1y_left + c2y_left)\n cmx_right, cmy_right = \\\n 0.5 * (c1x_right + c2x_right), 0.5 * (c1y_right + c2y_right)\n else:\n cmx_left, cmy_left = \\\n get_intersection(c1x_left, c1y_left, cos_t1, sin_t1,\n c2x_left, c2y_left, cos_t2, sin_t2)\n\n cmx_right, cmy_right = \\\n get_intersection(c1x_right, c1y_right, cos_t1, sin_t1,\n c2x_right, c2y_right, cos_t2, sin_t2)\n\n # the parralel bezier lines are created with control points of\n # [c1_left, cm_left, c2_left] and [c1_right, cm_right, c2_right]\n path_left = [(c1x_left, c1y_left),\n (cmx_left, cmy_left),\n (c2x_left, c2y_left)]\n path_right = [(c1x_right, c1y_right),\n (cmx_right, cmy_right),\n (c2x_right, c2y_right)]\n\n return path_left, path_right\n\n\ndef find_control_points(c1x, c1y, mmx, mmy, c2x, c2y):\n \"\"\" Find control points of the bezier line throught c1, mm, c2. We\n simply assume that c1, mm, c2 which have parametric value 0, 0.5, and 1.\n \"\"\"\n\n cmx = .5 * (4 * mmx - (c1x + c2x))\n cmy = .5 * (4 * mmy - (c1y + c2y))\n\n return [(c1x, c1y), (cmx, cmy), (c2x, c2y)]\n\n\ndef make_wedged_bezier2(bezier2, width, w1=1., wm=0.5, w2=0.):\n \"\"\"\n Being similar to get_parallels, returns control points of two quadrativ\n bezier lines having a width roughly parralel to given one separated by\n *width*.\n \"\"\"\n\n # c1, cm, c2\n c1x, c1y = bezier2[0]\n cmx, cmy = bezier2[1]\n c3x, c3y = bezier2[2]\n\n # t1 and t2 is the anlge between c1 and cm, cm, c3.\n # They are also a angle of the tangential line of the path at c1 and c3\n cos_t1, sin_t1 = get_cos_sin(c1x, c1y, cmx, cmy)\n cos_t2, sin_t2 = get_cos_sin(cmx, cmy, c3x, c3y)\n\n # find c1_left, c1_right which are located along the lines\n # throught c1 and perpendicular to the tangential lines of the\n # bezier path at a distance of width. Same thing for c3_left and\n # c3_right with respect to c3.\n c1x_left, c1y_left, c1x_right, c1y_right = \\\n get_normal_points(c1x, c1y, cos_t1, sin_t1, width * w1)\n c3x_left, c3y_left, c3x_right, c3y_right = \\\n get_normal_points(c3x, c3y, cos_t2, sin_t2, width * w2)\n\n # find c12, c23 and c123 which are middle points of c1-cm, cm-c3 and\n # c12-c23\n c12x, c12y = (c1x + cmx) * .5, (c1y + cmy) * .5\n c23x, c23y = (cmx + c3x) * .5, (cmy + c3y) * .5\n c123x, c123y = (c12x + c23x) * .5, (c12y + c23y) * .5\n\n # tangential angle of c123 (angle between c12 and c23)\n cos_t123, sin_t123 = get_cos_sin(c12x, c12y, c23x, c23y)\n\n c123x_left, c123y_left, c123x_right, c123y_right = \\\n get_normal_points(c123x, c123y, cos_t123, sin_t123, width * wm)\n\n path_left = find_control_points(c1x_left, c1y_left,\n c123x_left, c123y_left,\n c3x_left, c3y_left)\n path_right = find_control_points(c1x_right, c1y_right,\n c123x_right, c123y_right,\n c3x_right, c3y_right)\n\n return path_left, path_right\n\n\ndef make_path_regular(p):\n \"\"\"\n fill in the codes if None.\n \"\"\"\n c = p.codes\n if c is None:\n c = np.empty(p.vertices.shape[:1], \"i\")\n c.fill(Path.LINETO)\n c[0] = Path.MOVETO\n\n return Path(p.vertices, c)\n else:\n return p\n\n\ndef concatenate_paths(paths):\n \"\"\"\n concatenate list of paths into a single path.\n \"\"\"\n\n vertices = []\n codes = []\n for p in paths:\n p = make_path_regular(p)\n vertices.append(p.vertices)\n codes.append(p.codes)\n\n _path = Path(np.concatenate(vertices),\n np.concatenate(codes))\n return _path\n",
"#!/usr/bin/env python\n\n\n\"\"\"\nFor the backends that supports draw_image with optional affine\ntransform (e.g., agg, ps backend), the image of the output should\nhave its boundary matches the red rectangles.\n\"\"\"\n\nimport numpy as np\nimport matplotlib.cm as cm\nimport matplotlib.mlab as mlab\nimport matplotlib.pyplot as plt\nimport matplotlib.transforms as mtransforms\n\ndef get_image():\n delta = 0.25\n x = y = np.arange(-3.0, 3.0, delta)\n X, Y = np.meshgrid(x, y)\n Z1 = mlab.bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)\n Z2 = mlab.bivariate_normal(X, Y, 1.5, 0.5, 1, 1)\n Z = Z2-Z1 # difference of Gaussians\n return Z\n\ndef imshow_affine(ax, z, *kl, **kwargs):\n im = ax.imshow(z, *kl, **kwargs)\n x1, x2, y1, y2 = im.get_extent()\n im._image_skew_coordinate = (x2, y1)\n return im\n\n\nif 1:\n\n # image rotation\n\n fig, (ax1, ax2) = plt.subplots(1,2)\n Z = get_image()\n im1 = imshow_affine(ax1, Z, interpolation='none', cmap=cm.jet,\n origin='lower',\n extent=[-2, 4, -3, 2], clip_on=True)\n\n trans_data2 = mtransforms.Affine2D().rotate_deg(30) + ax1.transData\n im1.set_transform(trans_data2)\n\n # display intended extent of the image\n x1, x2, y1, y2 = im1.get_extent()\n x3, y3 = x2, y1\n\n ax1.plot([x1, x2, x2, x1, x1], [y1, y1, y2, y2, y1], \"r--\", lw=3,\n transform=trans_data2)\n\n ax1.set_xlim(-3, 5)\n ax1.set_ylim(-4, 4)\n\n\n # image skew\n\n im2 = ax2.imshow(Z, interpolation='none', cmap=cm.jet,\n origin='lower',\n extent=[-2, 4, -3, 2], clip_on=True)\n im2._image_skew_coordinate = (3, -2)\n\n\n plt.show()\n #plt.savefig(\"demo_affine_image\")\n"
] |
[
[
"numpy.nextafter",
"numpy.exp",
"numpy.sign",
"numpy.where",
"numpy.alltrue",
"numpy.sort",
"numpy.size",
"numpy.cos",
"numpy.gradient",
"numpy.ma.min",
"numpy.zeros_like",
"matplotlib.cbook.is_string_like",
"numpy.empty",
"numpy.sin",
"numpy.log",
"numpy.ma.asarray",
"numpy.hypot",
"matplotlib.cbook.deprecated",
"numpy.ma.masked_less_equal",
"numpy.empty_like",
"numpy.array",
"numpy.zeros",
"numpy.round",
"matplotlib.cbook.iterable",
"numpy.ma.getmaskarray",
"numpy.arctan2",
"matplotlib.cbook._putmask",
"numpy.clip",
"numpy.searchsorted",
"numpy.ma.getmask",
"numpy.asarray",
"numpy.ones",
"numpy.__version__.split",
"numpy.ma.max",
"numpy.ma.array",
"numpy.abs",
"numpy.linspace",
"numpy.ma.power"
],
[
"matplotlib.pyplot.show",
"numpy.arange",
"matplotlib.pyplot.subplots"
],
[
"numpy.dot",
"numpy.arccos",
"matplotlib.artist.get_window_extent",
"matplotlib.artist.Artist.get_transform",
"matplotlib.bezier.get_normal_points",
"matplotlib.bezier.split_path_inout",
"numpy.cos",
"matplotlib.cbook.dedent",
"matplotlib.artist.Artist.update_from",
"matplotlib.docstring.dedent_interpd",
"matplotlib.artist.kwdoc",
"numpy.concatenate",
"numpy.sin",
"matplotlib.bezier.get_cos_sin",
"matplotlib.transforms.IdentityTransform",
"matplotlib.transforms.BboxTransformTo",
"matplotlib.path.Path.unit_regular_polygon",
"numpy.sqrt",
"matplotlib.transforms.Affine2D",
"numpy.vstack",
"numpy.array",
"matplotlib.cbook._NestedClassGetter",
"matplotlib.cbook.iterable",
"matplotlib.transforms.Bbox.from_bounds",
"matplotlib.bezier.make_path_regular",
"matplotlib.bezier.inside_circle",
"matplotlib.artist.Artist.__init__",
"numpy.hstack",
"matplotlib.bezier.get_intersection",
"matplotlib.path.Path",
"matplotlib.path.Path.unit_circle",
"numpy.asarray",
"matplotlib.docstring.interpd.update",
"matplotlib.path.Path.arc",
"matplotlib.transforms.Affine2D.from_values",
"matplotlib.bezier.concatenate_paths",
"matplotlib.colors.colorConverter.to_rgba",
"matplotlib.bezier.make_wedged_bezier2",
"matplotlib.bezier.split_bezier_intersecting_with_closedpath",
"numpy.abs",
"matplotlib.path.Path.unit_rectangle",
"matplotlib.bezier.get_parallels",
"matplotlib.artist.Artist.set_alpha"
],
[
"numpy.concatenate",
"matplotlib.path.Path",
"numpy.array",
"numpy.empty",
"numpy.asarray",
"numpy.arange",
"numpy.arctan2",
"numpy.abs",
"numpy.power"
],
[
"matplotlib.pyplot.subplots",
"numpy.arange",
"matplotlib.pyplot.show",
"matplotlib.mlab.bivariate_normal",
"numpy.meshgrid",
"matplotlib.transforms.Affine2D"
]
] |
brobeson/vta
|
[
"01bc98137bab7171c9fe69770090ab01b2b10ae6"
] |
[
"vta/loss/loss.py"
] |
[
"\"\"\"The entry module for the vta loss command.\"\"\"\n\nimport argparse\nimport json\n\nimport matplotlib.pyplot as plt\nimport numpy\nimport scipy.interpolate\nimport sklearn.linear_model\n\nimport vta.loss.data\n\n\ndef main(arguments, configuration):\n \"\"\"Runs the vta loss command.\n\n This is the main entry point for the VTA loss command. It will draw graphs\n of data related to machine learning loss during training.\n\n :param argparse.Namespace arguments: The command line arguments, as parsed\n by the :py:mod:`argparse` module. Run `vta loss --help` for details.\n :param dict configuration: An optional run time configuration. In normal\n use, this will have been read from a YAML file.\n :return: An exit code following Unix command conventions. 0 indicates that\n command processing succeeded. Any other value indicates that an error\n occurred.\n :rtype: int\n \"\"\"\n configuration = _augment_configuration(configuration[\"loss\"])\n losses = _read_loss_data(arguments.file)\n if configuration[\"reject_invalid_data\"]:\n losses = [l for l in losses if _filter_invalid_data(l)]\n figure = plt.figure(figsize=(15, 10))\n axes = _make_axes(figure, configuration)\n _graph_loss(configuration, axes, losses)\n _graph_precision(configuration, axes, losses)\n axes.legend() # This must remain after the data is graphed.\n plt.show()\n\n\ndef make_parser(subparsers, common_options):\n \"\"\"Creates an argument parser for the VTA loss command.\n\n :param subparsers: The subparsers object returned by a call to\n :py:func:`argparse.ArgumentParser.add_subparsers`. The loss\n argument parser will be added to this.\n\n :return: Nothing\n \"\"\"\n parser = subparsers.add_parser(\n \"loss\",\n help=\"Analyze data related to machine learning training loss.\",\n prog=\"vta loss\",\n description=\"This command can be used to draw graphs of data related to\"\n \" machine learning loss.\",\n parents=[common_options],\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n )\n parser.add_argument(\n \"file\", help=\"The JSON file that has the loss data to graph.\", nargs=\"+\"\n )\n\n\n# -----------------------------------------------------------------------------\n# implementation details\n# -----------------------------------------------------------------------------\ndef _filter_invalid_data(data):\n if vta.loss.data.has_invalid_values(data):\n print(\"warning:\", data.label, \"has invalid data\")\n return False\n return True\n\n\ndef _graph_loss(configuration, axes, losses):\n if not configuration[\"draw_loss\"]:\n return\n vta.loss.data.sort_by_loss(losses, configuration[\"sort_algorithm\"])\n for loss in losses[0 : configuration[\"maximum_graphs\"]]:\n value = loss.loss_values[-1]\n axes.plot(\n range(len(loss.loss_values)),\n loss.loss_values,\n label=f\"[{value:.3f}] {loss.label}\",\n linestyle=\"-\" if configuration[\"line_loss\"] else \"\",\n marker=\".\" if configuration[\"scatter_loss\"] else \"\",\n )\n\n\ndef _graph_precision(configuration, axes, precisions):\n if not configuration[\"draw_precision\"]:\n return\n vta.loss.data.sort_by_precision(precisions, configuration[\"sort_algorithm\"])\n for precision in precisions[0 : configuration[\"maximum_graphs\"]]:\n value = precision.precision_values[-1]\n axes.plot(\n range(len(precision.precision_values)),\n precision.precision_values,\n label=f\"[{value:.3f}] {precision.label}\",\n linestyle=\"-\" if configuration[\"line_precision\"] else \"\",\n marker=\".\" if configuration[\"scatter_precision\"] else \"\",\n )\n\n\ndef _augment_configuration(configuration):\n configuration[\"draw_loss\"] = (\n configuration[\"scatter_loss\"] or configuration[\"line_loss\"]\n )\n configuration[\"draw_precision\"] = (\n configuration[\"scatter_precision\"] or configuration[\"line_precision\"]\n )\n # configuration[\"sort_algorithm\"] = configuration[\"sort_algorithm\"].lower()\n return configuration\n\n\ndef _read_loss_data(file_paths):\n losses = vta.loss.data.LossList()\n for file_path in file_paths:\n with open(file_path) as loss_file:\n data = json.load(loss_file)\n losses.append(\n vta.loss.data.Loss(\n data[\"label\"] if \"label\" in data else file_path,\n numpy.array(data[\"loss\"]),\n numpy.array(data[\"precision\"]),\n )\n )\n return losses\n\n\ndef _has_invalid_values(data):\n return numpy.any(numpy.logical_not(numpy.isfinite(data)))\n\n\ndef _make_axes(figure, configuration):\n axes = figure.add_subplot(1, 1, 1)\n axes.set_xlabel(\"Training Epoch\")\n if configuration[\"draw_loss\"] and configuration[\"draw_precision\"]:\n axes.set_title(\"Loss and Precision\")\n axes.set_ylabel(\"Loss / Precision\")\n elif configuration[\"draw_loss\"]:\n axes.set_title(\"Loss\")\n axes.set_ylabel(\"Loss\")\n elif configuration[\"draw_precision\"]:\n axes.set_title(\"Precision\")\n axes.set_ylabel(\"Precision\")\n axes.autoscale(enable=True, axis=\"both\", tight=True)\n axes.grid(\n b=True, which=\"major\", axis=\"both\", color=\"#101010\", alpha=0.5, linestyle=\":\"\n )\n return axes\n\n\ndef _graph_regression(axes, data):\n \"\"\"\n .. todo:: See issue #7\n \"\"\"\n regression = sklearn.linear_model.LinearRegression()\n x_data = numpy.arange(len(data)) # pylint: disable=invalid-name\n regression.fit(x_data.reshape(-1, 1), numpy.array(data).reshape(-1, 1))\n # x_data = numpy.arange(0.0, len(data), 0.1)\n x_data = numpy.linspace(0.0, len(data), 100)\n prediction = regression.predict(x_data.reshape(-1, 1))\n axes.plot(x_data, prediction)\n\n\ndef _graph_fit(axes, data):\n \"\"\"\n .. todo:: See issue #7\n \"\"\"\n interpolation = scipy.interpolate.interp1d(range(len(data)), data)\n x_data = numpy.linspace(0, len(data), 100)\n axes.plot(x_data, interpolation(x_data))\n"
] |
[
[
"matplotlib.pyplot.show",
"numpy.array",
"numpy.isfinite",
"matplotlib.pyplot.figure"
]
] |
wrld/PRoGAN
|
[
"ef28d4b91b76dd7f9e7d466b007826491bce5080"
] |
[
"phase_correlation/phase_corr.py"
] |
[
"import sys\nimport os\nsys.path.append(os.path.abspath(\"..\"))\n\nimport cv2\nimport math\nimport torch\nimport kornia\nimport numpy as np\nimport torch.nn as nn\nfrom numpy.fft import fft2, ifft2, fftshift\nimport torch.nn.functional as F\nfrom torch.autograd import Variable\nfrom torchvision import transforms, utils\nimport matplotlib.pyplot as plt\nfrom util.utils import *\nfrom log_polar.log_polar import *\n\n\ndef phase_corr(a, b, device, logbase, trans=False):\n # a: template; b: source\n # imshow(a.squeeze(0).float())\n G_a = torch.rfft(a, 2, onesided=False)\n G_b = torch.rfft(b, 2, onesided=False)\n eps = 1e-15\n\n real_a = G_a[:, :, :, 0]\n real_b = G_b[:, :, :, 0]\n imag_a = G_a[:, :, :, 1]\n imag_b = G_b[:, :, :, 1]\n\n # compute a * b.conjugate; shape=[B,H,W,C]\n R = torch.FloatTensor(G_a.shape[0], G_a.shape[1], G_a.shape[2],\n 2).to(device)\n R[:, :, :, 0] = real_a * real_b + imag_a * imag_b\n R[:, :, :, 1] = real_a * imag_b - real_b * imag_a\n\n r0 = torch.sqrt(real_a**2 + imag_a**2 + eps) * torch.sqrt(real_b**2 +\n imag_b**2 + eps)\n R[:, :, :, 0] = R[:, :, :, 0].clone() / (r0 + eps).to(device)\n R[:, :, :, 1] = R[:, :, :, 1].clone() / (r0 + eps).to(device)\n\n r = torch.ifft(R, 2)\n r_real = r[:, :, :, 0]\n r_imag = r[:, :, :, 1]\n r = torch.sqrt(r_real**2 + r_imag**2 + eps)\n r = fftshift2d(r)\n if trans:\n r[:, 0:60, :] = 0.\n r[:, G_a.shape[1] - 60:G_a.shape[1], :] = 0.\n r[:, :, 0:60] = 0.\n r[:, :, G_a.shape[1] - 60:G_a.shape[1]] = 0.\n # imshow(r[0,:,:])\n # plt.show()\n\n angle_resize_out_tensor = torch.sum(r.clone(), 2, keepdim=False)\n scale_reszie_out_tensor = torch.sum(r.clone(), 1, keepdim=False)\n # get the argmax of the angle and the scale\n angle_out_tensor = torch.argmax(angle_resize_out_tensor.clone().detach(),\n dim=-1)\n scale_out_tensor = torch.argmax(scale_reszie_out_tensor.clone().detach(),\n dim=-1)\n if not trans:\n angle_out_tensor = angle_out_tensor * 180.00 / r.shape[1]\n for batch_num in range(angle_out_tensor.shape[0]):\n if angle_out_tensor[batch_num].item() > 90:\n angle_out_tensor[batch_num] -= 90.00\n else:\n angle_out_tensor[batch_num] += 90.00\n\n logbase = logbase.to(device)\n\n # sca_f = scale_out_tensor.clone() * 256 / r.shape[2] - 256 // 2\n scale_out_tensor = 1 / torch.pow(\n logbase, scale_out_tensor.clone()) #logbase ** sca_f\n\n return scale_out_tensor, angle_out_tensor, r, logbase\n\n\ndef highpass(shape):\n \"\"\"Return highpass filter to be multiplied with fourier transform.\"\"\"\n i1 = torch.cos(torch.linspace(-np.pi / 2.0, np.pi / 2.0, shape[0]))\n i2 = torch.cos(torch.linspace(-np.pi / 2.0, np.pi / 2.0, shape[1]))\n x = torch.einsum('i,j->ij', i1, i2)\n return (1.0 - x) * (1.0 - x)\n\n\ndef logpolar_filter(shape):\n \"\"\"\n Make a radial cosine filter for the logpolar transform.\n This filter suppresses low frequencies and completely removes\n the zero freq.\n \"\"\"\n yy = np.linspace(-np.pi / 2., np.pi / 2., shape[0])[:, np.newaxis]\n xx = np.linspace(-np.pi / 2., np.pi / 2., shape[1])[np.newaxis, :]\n # Supressing low spatial frequencies is a must when using log-polar\n # transform. The scale stuff is poorly reflected with low freqs.\n rads = np.sqrt(yy**2 + xx**2)\n filt = 1.0 - np.cos(rads)**2\n # vvv This doesn't really matter, very high freqs are not too usable anyway\n filt[np.abs(rads) > np.pi / 2] = 1\n filt = torch.from_numpy(filt)\n return filt\n\n\nclass LogPolar(nn.Module):\n def __init__(self, out_size, device):\n super(LogPolar, self).__init__()\n self.out_size = out_size\n self.device = device\n\n def forward(self, input):\n return polar_transformer(input, self.out_size, self.device)\n\n\nclass PhaseCorr(nn.Module):\n def __init__(self, device, logbase, trans=False):\n super(PhaseCorr, self).__init__()\n self.device = device\n self.logbase = logbase\n self.trans = trans\n\n def forward(self, template, source):\n return phase_corr(template,\n source,\n self.device,\n self.logbase,\n trans=self.trans)\n\n\n"
] |
[
[
"torch.rfft",
"torch.sqrt",
"torch.einsum",
"torch.FloatTensor",
"torch.linspace",
"torch.from_numpy",
"torch.ifft",
"numpy.sqrt",
"numpy.cos",
"numpy.abs",
"numpy.linspace"
]
] |
Ptrskay3/pandas
|
[
"eca60680df2d4b7973d9e5b8252b7b9be3f96c3c"
] |
[
"pandas/core/window/rolling.py"
] |
[
"\"\"\"\nProvide a generic structure to support window functions,\nsimilar to how we have a Groupby object.\n\"\"\"\nfrom datetime import timedelta\nfrom functools import partial\nimport inspect\nfrom textwrap import dedent\nfrom typing import (\n TYPE_CHECKING,\n Callable,\n Dict,\n List,\n Optional,\n Set,\n Tuple,\n Type,\n Union,\n)\n\nimport numpy as np\n\nfrom pandas._libs.tslibs import BaseOffset, to_offset\nimport pandas._libs.window.aggregations as window_aggregations\nfrom pandas._typing import ArrayLike, Axis, FrameOrSeriesUnion, Label\nfrom pandas.compat._optional import import_optional_dependency\nfrom pandas.compat.numpy import function as nv\nfrom pandas.util._decorators import Appender, Substitution, cache_readonly, doc\n\nfrom pandas.core.dtypes.common import (\n ensure_float64,\n is_bool,\n is_float_dtype,\n is_integer,\n is_integer_dtype,\n is_list_like,\n is_scalar,\n needs_i8_conversion,\n)\nfrom pandas.core.dtypes.generic import (\n ABCDataFrame,\n ABCDatetimeIndex,\n ABCPeriodIndex,\n ABCSeries,\n ABCTimedeltaIndex,\n)\n\nfrom pandas.core.base import DataError, PandasObject, SelectionMixin, ShallowMixin\nimport pandas.core.common as com\nfrom pandas.core.construction import extract_array\nfrom pandas.core.indexes.api import Index, MultiIndex\nfrom pandas.core.util.numba_ import NUMBA_FUNC_CACHE, maybe_use_numba\nfrom pandas.core.window.common import (\n WindowGroupByMixin,\n _doc_template,\n _flex_binary_moment,\n _shared_docs,\n zsqrt,\n)\nfrom pandas.core.window.indexers import (\n BaseIndexer,\n FixedWindowIndexer,\n GroupbyRollingIndexer,\n VariableWindowIndexer,\n)\nfrom pandas.core.window.numba_ import generate_numba_apply_func\n\nif TYPE_CHECKING:\n from pandas import Series\n\n\ndef calculate_center_offset(window) -> int:\n \"\"\"\n Calculate an offset necessary to have the window label to be centered.\n\n Parameters\n ----------\n window: ndarray or int\n window weights or window\n\n Returns\n -------\n int\n \"\"\"\n if not is_integer(window):\n window = len(window)\n return int((window - 1) / 2.0)\n\n\ndef calculate_min_periods(\n window: int,\n min_periods: Optional[int],\n num_values: int,\n required_min_periods: int,\n floor: int,\n) -> int:\n \"\"\"\n Calculate final minimum periods value for rolling aggregations.\n\n Parameters\n ----------\n window : passed window value\n min_periods : passed min periods value\n num_values : total number of values\n required_min_periods : required min periods per aggregation function\n floor : required min periods per aggregation function\n\n Returns\n -------\n min_periods : int\n \"\"\"\n if min_periods is None:\n min_periods = window\n else:\n min_periods = max(required_min_periods, min_periods)\n if min_periods > window:\n raise ValueError(f\"min_periods {min_periods} must be <= window {window}\")\n elif min_periods > num_values:\n min_periods = num_values + 1\n elif min_periods < 0:\n raise ValueError(\"min_periods must be >= 0\")\n return max(min_periods, floor)\n\n\ndef get_weighted_roll_func(cfunc: Callable) -> Callable:\n \"\"\"\n Wrap weighted rolling cython function with min periods argument.\n\n Parameters\n ----------\n cfunc : function\n Cython weighted rolling function\n\n Returns\n -------\n function\n \"\"\"\n\n def func(arg, window, min_periods=None):\n if min_periods is None:\n min_periods = len(window)\n return cfunc(arg, window, min_periods)\n\n return func\n\n\nclass _Window(PandasObject, ShallowMixin, SelectionMixin):\n _attributes: List[str] = [\n \"window\",\n \"min_periods\",\n \"center\",\n \"win_type\",\n \"axis\",\n \"on\",\n \"closed\",\n ]\n exclusions: Set[str] = set()\n\n def __init__(\n self,\n obj: FrameOrSeriesUnion,\n window=None,\n min_periods: Optional[int] = None,\n center: bool = False,\n win_type: Optional[str] = None,\n axis: Axis = 0,\n on: Optional[Union[str, Index]] = None,\n closed: Optional[str] = None,\n **kwargs,\n ):\n\n self.__dict__.update(kwargs)\n self.obj = obj\n self.on = on\n self.closed = closed\n self.window = window\n self.min_periods = min_periods\n self.center = center\n self.win_type = win_type\n self.win_freq = None\n self.axis = obj._get_axis_number(axis) if axis is not None else None\n self.validate()\n\n @property\n def _constructor(self):\n return Window\n\n @property\n def is_datetimelike(self) -> Optional[bool]:\n return None\n\n @property\n def _on(self):\n return None\n\n @property\n def is_freq_type(self) -> bool:\n return self.win_type == \"freq\"\n\n def validate(self) -> None:\n if self.center is not None and not is_bool(self.center):\n raise ValueError(\"center must be a boolean\")\n if self.min_periods is not None and not is_integer(self.min_periods):\n raise ValueError(\"min_periods must be an integer\")\n if self.closed is not None and self.closed not in [\n \"right\",\n \"both\",\n \"left\",\n \"neither\",\n ]:\n raise ValueError(\"closed must be 'right', 'left', 'both' or 'neither'\")\n if not isinstance(self.obj, (ABCSeries, ABCDataFrame)):\n raise TypeError(f\"invalid type: {type(self)}\")\n if isinstance(self.window, BaseIndexer):\n self._validate_get_window_bounds_signature(self.window)\n\n @staticmethod\n def _validate_get_window_bounds_signature(window: BaseIndexer) -> None:\n \"\"\"\n Validate that the passed BaseIndexer subclass has\n a get_window_bounds with the correct signature.\n \"\"\"\n get_window_bounds_signature = inspect.signature(\n window.get_window_bounds\n ).parameters.keys()\n expected_signature = inspect.signature(\n BaseIndexer().get_window_bounds\n ).parameters.keys()\n if get_window_bounds_signature != expected_signature:\n raise ValueError(\n f\"{type(window).__name__} does not implement the correct signature for \"\n f\"get_window_bounds\"\n )\n\n def _create_blocks(self, obj: FrameOrSeriesUnion):\n \"\"\"\n Split data into blocks & return conformed data.\n \"\"\"\n # filter out the on from the object\n if self.on is not None and not isinstance(self.on, Index):\n if obj.ndim == 2:\n obj = obj.reindex(columns=obj.columns.difference([self.on]), copy=False)\n blocks = obj._to_dict_of_blocks(copy=False).values()\n\n return blocks, obj\n\n def _gotitem(self, key, ndim, subset=None):\n \"\"\"\n Sub-classes to define. Return a sliced object.\n\n Parameters\n ----------\n key : str / list of selections\n ndim : 1,2\n requested ndim of result\n subset : object, default None\n subset to act on\n \"\"\"\n # create a new object to prevent aliasing\n if subset is None:\n subset = self.obj\n self = self._shallow_copy(subset)\n self._reset_cache()\n if subset.ndim == 2:\n if is_scalar(key) and key in subset or is_list_like(key):\n self._selection = key\n return self\n\n def __getattr__(self, attr: str):\n if attr in self._internal_names_set:\n return object.__getattribute__(self, attr)\n if attr in self.obj:\n return self[attr]\n\n raise AttributeError(\n f\"'{type(self).__name__}' object has no attribute '{attr}'\"\n )\n\n def _dir_additions(self):\n return self.obj._dir_additions()\n\n def _get_win_type(self, kwargs: Dict):\n \"\"\"\n Exists for compatibility, overridden by subclass Window.\n\n Parameters\n ----------\n kwargs : dict\n ignored, exists for compatibility\n\n Returns\n -------\n None\n \"\"\"\n return None\n\n def _get_window(self, other=None, win_type: Optional[str] = None) -> int:\n \"\"\"\n Return window length.\n\n Parameters\n ----------\n other :\n ignored, exists for compatibility\n win_type :\n ignored, exists for compatibility\n\n Returns\n -------\n window : int\n \"\"\"\n if isinstance(self.window, BaseIndexer):\n return self.min_periods or 0\n return self.window\n\n @property\n def _window_type(self) -> str:\n return type(self).__name__\n\n def __repr__(self) -> str:\n \"\"\"\n Provide a nice str repr of our rolling object.\n \"\"\"\n attrs_list = (\n f\"{attr_name}={getattr(self, attr_name)}\"\n for attr_name in self._attributes\n if getattr(self, attr_name, None) is not None\n )\n attrs = \",\".join(attrs_list)\n return f\"{self._window_type} [{attrs}]\"\n\n def __iter__(self):\n window = self._get_window(win_type=None)\n _, obj = self._create_blocks(self._selected_obj)\n index = self._get_window_indexer(window=window)\n\n start, end = index.get_window_bounds(\n num_values=len(obj),\n min_periods=self.min_periods,\n center=self.center,\n closed=self.closed,\n )\n # From get_window_bounds, those two should be equal in length of array\n assert len(start) == len(end)\n\n for s, e in zip(start, end):\n result = obj.iloc[slice(s, e)]\n yield result\n\n def _prep_values(self, values: Optional[np.ndarray] = None) -> np.ndarray:\n \"\"\"Convert input to numpy arrays for Cython routines\"\"\"\n if values is None:\n values = extract_array(self._selected_obj, extract_numpy=True)\n\n # GH #12373 : rolling functions error on float32 data\n # make sure the data is coerced to float64\n if is_float_dtype(values.dtype):\n values = ensure_float64(values)\n elif is_integer_dtype(values.dtype):\n values = ensure_float64(values)\n elif needs_i8_conversion(values.dtype):\n raise NotImplementedError(\n f\"ops for {self._window_type} for this \"\n f\"dtype {values.dtype} are not implemented\"\n )\n else:\n try:\n values = ensure_float64(values)\n except (ValueError, TypeError) as err:\n raise TypeError(f\"cannot handle this type -> {values.dtype}\") from err\n\n # Convert inf to nan for C funcs\n inf = np.isinf(values)\n if inf.any():\n values = np.where(inf, np.nan, values)\n\n return values\n\n def _wrap_result(self, result, block=None, obj=None):\n \"\"\"\n Wrap a single result.\n \"\"\"\n if obj is None:\n obj = self._selected_obj\n index = obj.index\n\n if isinstance(result, np.ndarray):\n\n if result.ndim == 1:\n from pandas import Series\n\n return Series(result, index, name=obj.name)\n\n return type(obj)(result, index=index, columns=block.columns)\n return result\n\n def _wrap_results(self, results, obj, skipped: List[int]) -> FrameOrSeriesUnion:\n \"\"\"\n Wrap the results.\n\n Parameters\n ----------\n results : list of ndarrays\n obj : conformed data (may be resampled)\n skipped: List[int]\n Indices of blocks that are skipped.\n \"\"\"\n from pandas import Series, concat\n\n if obj.ndim == 1:\n if not results:\n raise DataError(\"No numeric types to aggregate\")\n assert len(results) == 1\n return Series(results[0], index=obj.index, name=obj.name)\n\n exclude: List[Label] = []\n orig_blocks = list(obj._to_dict_of_blocks(copy=False).values())\n for i in skipped:\n exclude.extend(orig_blocks[i].columns)\n\n kept_blocks = [blk for i, blk in enumerate(orig_blocks) if i not in skipped]\n\n final = []\n for result, block in zip(results, kept_blocks):\n\n result = type(obj)(result, index=obj.index, columns=block.columns)\n final.append(result)\n\n exclude = exclude or []\n columns = [c for c in self._selected_obj.columns if c not in exclude]\n if not columns and not len(final) and exclude:\n raise DataError(\"No numeric types to aggregate\")\n elif not len(final):\n return obj.astype(\"float64\")\n\n df = concat(final, axis=1).reindex(columns=columns, copy=False)\n\n # if we have an 'on' column we want to put it back into\n # the results in the same location\n if self.on is not None and not self._on.equals(obj.index):\n name = self._on.name\n extra_col = Series(self._on, index=obj.index, name=name)\n if name not in df.columns and name not in df.index.names:\n new_loc = len(df.columns)\n df.insert(new_loc, name, extra_col)\n elif name in df.columns:\n # TODO: sure we want to overwrite results?\n df[name] = extra_col\n return df\n\n def _center_window(self, result, window) -> np.ndarray:\n \"\"\"\n Center the result in the window.\n \"\"\"\n if self.axis > result.ndim - 1:\n raise ValueError(\"Requested axis is larger then no. of argument dimensions\")\n\n offset = calculate_center_offset(window)\n if offset > 0:\n lead_indexer = [slice(None)] * result.ndim\n lead_indexer[self.axis] = slice(offset, None)\n result = np.copy(result[tuple(lead_indexer)])\n return result\n\n def _get_roll_func(self, func_name: str) -> Callable:\n \"\"\"\n Wrap rolling function to check values passed.\n\n Parameters\n ----------\n func_name : str\n Cython function used to calculate rolling statistics\n\n Returns\n -------\n func : callable\n \"\"\"\n window_func = getattr(window_aggregations, func_name, None)\n if window_func is None:\n raise ValueError(\n f\"we do not support this function in window_aggregations.{func_name}\"\n )\n return window_func\n\n def _get_cython_func_type(self, func: str) -> Callable:\n \"\"\"\n Return a variable or fixed cython function type.\n\n Variable algorithms do not use window while fixed do.\n \"\"\"\n if self.is_freq_type or isinstance(self.window, BaseIndexer):\n return self._get_roll_func(f\"{func}_variable\")\n return partial(self._get_roll_func(f\"{func}_fixed\"), win=self._get_window())\n\n def _get_window_indexer(self, window: int) -> BaseIndexer:\n \"\"\"\n Return an indexer class that will compute the window start and end bounds\n \"\"\"\n if isinstance(self.window, BaseIndexer):\n return self.window\n if self.is_freq_type:\n return VariableWindowIndexer(index_array=self._on.asi8, window_size=window)\n return FixedWindowIndexer(window_size=window)\n\n def _apply_series(self, homogeneous_func: Callable[..., ArrayLike]) -> \"Series\":\n \"\"\"\n Series version of _apply_blockwise\n \"\"\"\n _, obj = self._create_blocks(self._selected_obj)\n values = obj.values\n\n try:\n values = self._prep_values(obj.values)\n except (TypeError, NotImplementedError) as err:\n raise DataError(\"No numeric types to aggregate\") from err\n\n result = homogeneous_func(values)\n return obj._constructor(result, index=obj.index, name=obj.name)\n\n def _apply_blockwise(\n self, homogeneous_func: Callable[..., ArrayLike]\n ) -> FrameOrSeriesUnion:\n \"\"\"\n Apply the given function to the DataFrame broken down into homogeneous\n sub-frames.\n \"\"\"\n if self._selected_obj.ndim == 1:\n return self._apply_series(homogeneous_func)\n\n # This isn't quite blockwise, since `blocks` is actually a collection\n # of homogenenous DataFrames.\n blocks, obj = self._create_blocks(self._selected_obj)\n\n skipped: List[int] = []\n results: List[ArrayLike] = []\n for i, b in enumerate(blocks):\n try:\n values = self._prep_values(b.values)\n\n except (TypeError, NotImplementedError):\n skipped.append(i)\n continue\n\n result = homogeneous_func(values)\n results.append(result)\n\n return self._wrap_results(results, obj, skipped)\n\n def _apply(\n self,\n func: Callable,\n center: bool,\n require_min_periods: int = 0,\n floor: int = 1,\n is_weighted: bool = False,\n name: Optional[str] = None,\n use_numba_cache: bool = False,\n **kwargs,\n ):\n \"\"\"\n Rolling statistical measure using supplied function.\n\n Designed to be used with passed-in Cython array-based functions.\n\n Parameters\n ----------\n func : callable function to apply\n center : bool\n require_min_periods : int\n floor : int\n is_weighted : bool\n name : str,\n compatibility with groupby.rolling\n use_numba_cache : bool\n whether to cache a numba compiled function. Only available for numba\n enabled methods (so far only apply)\n **kwargs\n additional arguments for rolling function and window function\n\n Returns\n -------\n y : type of input\n \"\"\"\n win_type = self._get_win_type(kwargs)\n window = self._get_window(win_type=win_type)\n window_indexer = self._get_window_indexer(window)\n\n def homogeneous_func(values: np.ndarray):\n # calculation function\n\n if values.size == 0:\n return values.copy()\n\n offset = calculate_center_offset(window) if center else 0\n additional_nans = np.array([np.nan] * offset)\n\n if not is_weighted:\n\n def calc(x):\n x = np.concatenate((x, additional_nans))\n if not isinstance(self.window, BaseIndexer):\n min_periods = calculate_min_periods(\n window, self.min_periods, len(x), require_min_periods, floor\n )\n else:\n min_periods = calculate_min_periods(\n window_indexer.window_size,\n self.min_periods,\n len(x),\n require_min_periods,\n floor,\n )\n start, end = window_indexer.get_window_bounds(\n num_values=len(x),\n min_periods=self.min_periods,\n center=self.center,\n closed=self.closed,\n )\n return func(x, start, end, min_periods)\n\n else:\n\n def calc(x):\n x = np.concatenate((x, additional_nans))\n return func(x, window, self.min_periods)\n\n with np.errstate(all=\"ignore\"):\n if values.ndim > 1:\n result = np.apply_along_axis(calc, self.axis, values)\n else:\n result = calc(values)\n result = np.asarray(result)\n\n if use_numba_cache:\n NUMBA_FUNC_CACHE[(kwargs[\"original_func\"], \"rolling_apply\")] = func\n\n if center:\n result = self._center_window(result, window)\n\n return result\n\n return self._apply_blockwise(homogeneous_func)\n\n def aggregate(self, func, *args, **kwargs):\n result, how = self._aggregate(func, *args, **kwargs)\n if result is None:\n return self.apply(func, raw=False, args=args, kwargs=kwargs)\n return result\n\n agg = aggregate\n\n _shared_docs[\"sum\"] = dedent(\n \"\"\"\n Calculate %(name)s sum of given DataFrame or Series.\n\n Parameters\n ----------\n *args, **kwargs\n For compatibility with other %(name)s methods. Has no effect\n on the computed value.\n\n Returns\n -------\n Series or DataFrame\n Same type as the input, with the same index, containing the\n %(name)s sum.\n\n See Also\n --------\n pandas.Series.sum : Reducing sum for Series.\n pandas.DataFrame.sum : Reducing sum for DataFrame.\n\n Examples\n --------\n >>> s = pd.Series([1, 2, 3, 4, 5])\n >>> s\n 0 1\n 1 2\n 2 3\n 3 4\n 4 5\n dtype: int64\n\n >>> s.rolling(3).sum()\n 0 NaN\n 1 NaN\n 2 6.0\n 3 9.0\n 4 12.0\n dtype: float64\n\n >>> s.expanding(3).sum()\n 0 NaN\n 1 NaN\n 2 6.0\n 3 10.0\n 4 15.0\n dtype: float64\n\n >>> s.rolling(3, center=True).sum()\n 0 NaN\n 1 6.0\n 2 9.0\n 3 12.0\n 4 NaN\n dtype: float64\n\n For DataFrame, each %(name)s sum is computed column-wise.\n\n >>> df = pd.DataFrame({\"A\": s, \"B\": s ** 2})\n >>> df\n A B\n 0 1 1\n 1 2 4\n 2 3 9\n 3 4 16\n 4 5 25\n\n >>> df.rolling(3).sum()\n A B\n 0 NaN NaN\n 1 NaN NaN\n 2 6.0 14.0\n 3 9.0 29.0\n 4 12.0 50.0\n \"\"\"\n )\n\n _shared_docs[\"mean\"] = dedent(\n \"\"\"\n Calculate the %(name)s mean of the values.\n\n Parameters\n ----------\n *args\n Under Review.\n **kwargs\n Under Review.\n\n Returns\n -------\n Series or DataFrame\n Returned object type is determined by the caller of the %(name)s\n calculation.\n\n See Also\n --------\n pandas.Series.%(name)s : Calling object with Series data.\n pandas.DataFrame.%(name)s : Calling object with DataFrames.\n pandas.Series.mean : Equivalent method for Series.\n pandas.DataFrame.mean : Equivalent method for DataFrame.\n\n Examples\n --------\n The below examples will show rolling mean calculations with window sizes of\n two and three, respectively.\n\n >>> s = pd.Series([1, 2, 3, 4])\n >>> s.rolling(2).mean()\n 0 NaN\n 1 1.5\n 2 2.5\n 3 3.5\n dtype: float64\n\n >>> s.rolling(3).mean()\n 0 NaN\n 1 NaN\n 2 2.0\n 3 3.0\n dtype: float64\n \"\"\"\n )\n\n _shared_docs[\"var\"] = dedent(\n \"\"\"\n Calculate unbiased %(name)s variance.\n %(versionadded)s\n Normalized by N-1 by default. This can be changed using the `ddof`\n argument.\n\n Parameters\n ----------\n ddof : int, default 1\n Delta Degrees of Freedom. The divisor used in calculations\n is ``N - ddof``, where ``N`` represents the number of elements.\n *args, **kwargs\n For NumPy compatibility. No additional arguments are used.\n\n Returns\n -------\n Series or DataFrame\n Returns the same object type as the caller of the %(name)s calculation.\n\n See Also\n --------\n pandas.Series.%(name)s : Calling object with Series data.\n pandas.DataFrame.%(name)s : Calling object with DataFrames.\n pandas.Series.var : Equivalent method for Series.\n pandas.DataFrame.var : Equivalent method for DataFrame.\n numpy.var : Equivalent method for Numpy array.\n\n Notes\n -----\n The default `ddof` of 1 used in :meth:`Series.var` is different than the\n default `ddof` of 0 in :func:`numpy.var`.\n\n A minimum of 1 period is required for the rolling calculation.\n\n Examples\n --------\n >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n >>> s.rolling(3).var()\n 0 NaN\n 1 NaN\n 2 0.333333\n 3 1.000000\n 4 1.000000\n 5 1.333333\n 6 0.000000\n dtype: float64\n\n >>> s.expanding(3).var()\n 0 NaN\n 1 NaN\n 2 0.333333\n 3 0.916667\n 4 0.800000\n 5 0.700000\n 6 0.619048\n dtype: float64\n \"\"\"\n )\n\n _shared_docs[\"std\"] = dedent(\n \"\"\"\n Calculate %(name)s standard deviation.\n %(versionadded)s\n Normalized by N-1 by default. This can be changed using the `ddof`\n argument.\n\n Parameters\n ----------\n ddof : int, default 1\n Delta Degrees of Freedom. The divisor used in calculations\n is ``N - ddof``, where ``N`` represents the number of elements.\n *args, **kwargs\n For NumPy compatibility. No additional arguments are used.\n\n Returns\n -------\n Series or DataFrame\n Returns the same object type as the caller of the %(name)s calculation.\n\n See Also\n --------\n pandas.Series.%(name)s : Calling object with Series data.\n pandas.DataFrame.%(name)s : Calling object with DataFrames.\n pandas.Series.std : Equivalent method for Series.\n pandas.DataFrame.std : Equivalent method for DataFrame.\n numpy.std : Equivalent method for Numpy array.\n\n Notes\n -----\n The default `ddof` of 1 used in Series.std is different than the default\n `ddof` of 0 in numpy.std.\n\n A minimum of one period is required for the rolling calculation.\n\n Examples\n --------\n >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n >>> s.rolling(3).std()\n 0 NaN\n 1 NaN\n 2 0.577350\n 3 1.000000\n 4 1.000000\n 5 1.154701\n 6 0.000000\n dtype: float64\n\n >>> s.expanding(3).std()\n 0 NaN\n 1 NaN\n 2 0.577350\n 3 0.957427\n 4 0.894427\n 5 0.836660\n 6 0.786796\n dtype: float64\n \"\"\"\n )\n\n\nclass Window(_Window):\n \"\"\"\n Provide rolling window calculations.\n\n Parameters\n ----------\n window : int, offset, or BaseIndexer subclass\n Size of the moving window. This is the number of observations used for\n calculating the statistic. Each window will be a fixed size.\n\n If its an offset then this will be the time period of each window. Each\n window will be a variable sized based on the observations included in\n the time-period. This is only valid for datetimelike indexes.\n\n If a BaseIndexer subclass is passed, calculates the window boundaries\n based on the defined ``get_window_bounds`` method. Additional rolling\n keyword arguments, namely `min_periods`, `center`, and\n `closed` will be passed to `get_window_bounds`.\n min_periods : int, default None\n Minimum number of observations in window required to have a value\n (otherwise result is NA). For a window that is specified by an offset,\n `min_periods` will default to 1. Otherwise, `min_periods` will default\n to the size of the window.\n center : bool, default False\n Set the labels at the center of the window.\n win_type : str, default None\n Provide a window type. If ``None``, all points are evenly weighted.\n See the notes below for further information.\n on : str, optional\n For a DataFrame, a datetime-like column or MultiIndex level on which\n to calculate the rolling window, rather than the DataFrame's index.\n Provided integer column is ignored and excluded from result since\n an integer index is not used to calculate the rolling window.\n axis : int or str, default 0\n closed : str, default None\n Make the interval closed on the 'right', 'left', 'both' or\n 'neither' endpoints.\n For offset-based windows, it defaults to 'right'.\n For fixed windows, defaults to 'both'. Remaining cases not implemented\n for fixed windows.\n\n Returns\n -------\n a Window or Rolling sub-classed for the particular operation\n\n See Also\n --------\n expanding : Provides expanding transformations.\n ewm : Provides exponential weighted functions.\n\n Notes\n -----\n By default, the result is set to the right edge of the window. This can be\n changed to the center of the window by setting ``center=True``.\n\n To learn more about the offsets & frequency strings, please see `this link\n <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.\n\n The recognized win_types are:\n\n * ``boxcar``\n * ``triang``\n * ``blackman``\n * ``hamming``\n * ``bartlett``\n * ``parzen``\n * ``bohman``\n * ``blackmanharris``\n * ``nuttall``\n * ``barthann``\n * ``kaiser`` (needs parameter: beta)\n * ``gaussian`` (needs parameter: std)\n * ``general_gaussian`` (needs parameters: power, width)\n * ``slepian`` (needs parameter: width)\n * ``exponential`` (needs parameter: tau), center is set to None.\n\n If ``win_type=None`` all points are evenly weighted. To learn more about\n different window types see `scipy.signal window functions\n <https://docs.scipy.org/doc/scipy/reference/signal.html#window-functions>`__.\n\n Certain window types require additional parameters to be passed. Please see\n the third example below on how to add the additional parameters.\n\n Examples\n --------\n >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})\n >>> df\n B\n 0 0.0\n 1 1.0\n 2 2.0\n 3 NaN\n 4 4.0\n\n Rolling sum with a window length of 2, using the 'triang'\n window type.\n\n >>> df.rolling(2, win_type='triang').sum()\n B\n 0 NaN\n 1 0.5\n 2 1.5\n 3 NaN\n 4 NaN\n\n Rolling sum with a window length of 2, using the 'gaussian'\n window type (note how we need to specify std).\n\n >>> df.rolling(2, win_type='gaussian').sum(std=3)\n B\n 0 NaN\n 1 0.986207\n 2 2.958621\n 3 NaN\n 4 NaN\n\n Rolling sum with a window length of 2, min_periods defaults\n to the window length.\n\n >>> df.rolling(2).sum()\n B\n 0 NaN\n 1 1.0\n 2 3.0\n 3 NaN\n 4 NaN\n\n Same as above, but explicitly set the min_periods\n\n >>> df.rolling(2, min_periods=1).sum()\n B\n 0 0.0\n 1 1.0\n 2 3.0\n 3 2.0\n 4 4.0\n\n Same as above, but with forward-looking windows\n\n >>> indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=2)\n >>> df.rolling(window=indexer, min_periods=1).sum()\n B\n 0 1.0\n 1 3.0\n 2 2.0\n 3 4.0\n 4 4.0\n\n A ragged (meaning not-a-regular frequency), time-indexed DataFrame\n\n >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]},\n ... index = [pd.Timestamp('20130101 09:00:00'),\n ... pd.Timestamp('20130101 09:00:02'),\n ... pd.Timestamp('20130101 09:00:03'),\n ... pd.Timestamp('20130101 09:00:05'),\n ... pd.Timestamp('20130101 09:00:06')])\n\n >>> df\n B\n 2013-01-01 09:00:00 0.0\n 2013-01-01 09:00:02 1.0\n 2013-01-01 09:00:03 2.0\n 2013-01-01 09:00:05 NaN\n 2013-01-01 09:00:06 4.0\n\n Contrasting to an integer rolling window, this will roll a variable\n length window corresponding to the time period.\n The default for min_periods is 1.\n\n >>> df.rolling('2s').sum()\n B\n 2013-01-01 09:00:00 0.0\n 2013-01-01 09:00:02 1.0\n 2013-01-01 09:00:03 3.0\n 2013-01-01 09:00:05 NaN\n 2013-01-01 09:00:06 4.0\n \"\"\"\n\n def validate(self):\n super().validate()\n\n window = self.window\n if isinstance(window, BaseIndexer):\n raise NotImplementedError(\n \"BaseIndexer subclasses not implemented with win_types.\"\n )\n elif isinstance(window, (list, tuple, np.ndarray)):\n pass\n elif is_integer(window):\n if window <= 0:\n raise ValueError(\"window must be > 0 \")\n import_optional_dependency(\n \"scipy\", extra=\"Scipy is required to generate window weight.\"\n )\n import scipy.signal as sig\n\n if not isinstance(self.win_type, str):\n raise ValueError(f\"Invalid win_type {self.win_type}\")\n if getattr(sig, self.win_type, None) is None:\n raise ValueError(f\"Invalid win_type {self.win_type}\")\n else:\n raise ValueError(f\"Invalid window {window}\")\n\n def _get_win_type(self, kwargs: Dict) -> Union[str, Tuple]:\n \"\"\"\n Extract arguments for the window type, provide validation for it\n and return the validated window type.\n\n Parameters\n ----------\n kwargs : dict\n\n Returns\n -------\n win_type : str, or tuple\n \"\"\"\n # the below may pop from kwargs\n def _validate_win_type(win_type, kwargs):\n arg_map = {\n \"kaiser\": [\"beta\"],\n \"gaussian\": [\"std\"],\n \"general_gaussian\": [\"power\", \"width\"],\n \"slepian\": [\"width\"],\n \"exponential\": [\"tau\"],\n }\n\n if win_type in arg_map:\n win_args = _pop_args(win_type, arg_map[win_type], kwargs)\n if win_type == \"exponential\":\n # exponential window requires the first arg (center)\n # to be set to None (necessary for symmetric window)\n win_args.insert(0, None)\n\n return tuple([win_type] + win_args)\n\n return win_type\n\n def _pop_args(win_type, arg_names, kwargs):\n all_args = []\n for n in arg_names:\n if n not in kwargs:\n raise ValueError(f\"{win_type} window requires {n}\")\n all_args.append(kwargs.pop(n))\n return all_args\n\n return _validate_win_type(self.win_type, kwargs)\n\n def _get_window(\n self, other=None, win_type: Optional[Union[str, Tuple]] = None\n ) -> np.ndarray:\n \"\"\"\n Get the window, weights.\n\n Parameters\n ----------\n other :\n ignored, exists for compatibility\n win_type : str, or tuple\n type of window to create\n\n Returns\n -------\n window : ndarray\n the window, weights\n \"\"\"\n window = self.window\n if isinstance(window, (list, tuple, np.ndarray)):\n return com.asarray_tuplesafe(window).astype(float)\n elif is_integer(window):\n import scipy.signal as sig\n\n # GH #15662. `False` makes symmetric window, rather than periodic.\n return sig.get_window(win_type, window, False).astype(float)\n\n _agg_see_also_doc = dedent(\n \"\"\"\n See Also\n --------\n pandas.DataFrame.aggregate : Similar DataFrame method.\n pandas.Series.aggregate : Similar Series method.\n \"\"\"\n )\n\n _agg_examples_doc = dedent(\n \"\"\"\n Examples\n --------\n >>> df = pd.DataFrame({\"A\": [1, 2, 3], \"B\": [4, 5, 6], \"C\": [7, 8, 9]})\n >>> df\n A B C\n 0 1 4 7\n 1 2 5 8\n 2 3 6 9\n\n >>> df.rolling(2, win_type=\"boxcar\").agg(\"mean\")\n A B C\n 0 NaN NaN NaN\n 1 1.5 4.5 7.5\n 2 2.5 5.5 8.5\n \"\"\"\n )\n\n @doc(\n _shared_docs[\"aggregate\"],\n see_also=_agg_see_also_doc,\n examples=_agg_examples_doc,\n versionadded=\"\",\n klass=\"Series/DataFrame\",\n axis=\"\",\n )\n def aggregate(self, func, *args, **kwargs):\n result, how = self._aggregate(func, *args, **kwargs)\n if result is None:\n\n # these must apply directly\n result = func(self)\n\n return result\n\n agg = aggregate\n\n @Substitution(name=\"window\")\n @Appender(_shared_docs[\"sum\"])\n def sum(self, *args, **kwargs):\n nv.validate_window_func(\"sum\", args, kwargs)\n window_func = self._get_roll_func(\"roll_weighted_sum\")\n window_func = get_weighted_roll_func(window_func)\n return self._apply(\n window_func, center=self.center, is_weighted=True, name=\"sum\", **kwargs\n )\n\n @Substitution(name=\"window\")\n @Appender(_shared_docs[\"mean\"])\n def mean(self, *args, **kwargs):\n nv.validate_window_func(\"mean\", args, kwargs)\n window_func = self._get_roll_func(\"roll_weighted_mean\")\n window_func = get_weighted_roll_func(window_func)\n return self._apply(\n window_func, center=self.center, is_weighted=True, name=\"mean\", **kwargs\n )\n\n @Substitution(name=\"window\", versionadded=\"\\n.. versionadded:: 1.0.0\\n\")\n @Appender(_shared_docs[\"var\"])\n def var(self, ddof=1, *args, **kwargs):\n nv.validate_window_func(\"var\", args, kwargs)\n window_func = partial(self._get_roll_func(\"roll_weighted_var\"), ddof=ddof)\n window_func = get_weighted_roll_func(window_func)\n kwargs.pop(\"name\", None)\n return self._apply(\n window_func, center=self.center, is_weighted=True, name=\"var\", **kwargs\n )\n\n @Substitution(name=\"window\", versionadded=\"\\n.. versionadded:: 1.0.0\\n\")\n @Appender(_shared_docs[\"std\"])\n def std(self, ddof=1, *args, **kwargs):\n nv.validate_window_func(\"std\", args, kwargs)\n return zsqrt(self.var(ddof=ddof, name=\"std\", **kwargs))\n\n\nclass _Rolling(_Window):\n @property\n def _constructor(self):\n return Rolling\n\n\nclass _Rolling_and_Expanding(_Rolling):\n\n _shared_docs[\"count\"] = dedent(\n r\"\"\"\n The %(name)s count of any non-NaN observations inside the window.\n\n Returns\n -------\n Series or DataFrame\n Returned object type is determined by the caller of the %(name)s\n calculation.\n\n See Also\n --------\n pandas.Series.%(name)s : Calling object with Series data.\n pandas.DataFrame.%(name)s : Calling object with DataFrames.\n pandas.DataFrame.count : Count of the full DataFrame.\n\n Examples\n --------\n >>> s = pd.Series([2, 3, np.nan, 10])\n >>> s.rolling(2).count()\n 0 1.0\n 1 2.0\n 2 1.0\n 3 1.0\n dtype: float64\n >>> s.rolling(3).count()\n 0 1.0\n 1 2.0\n 2 2.0\n 3 2.0\n dtype: float64\n >>> s.rolling(4).count()\n 0 1.0\n 1 2.0\n 2 2.0\n 3 3.0\n dtype: float64\n \"\"\"\n )\n\n def count(self):\n # GH 32865. Using count with custom BaseIndexer subclass\n # implementations shouldn't end up here\n assert not isinstance(self.window, BaseIndexer)\n\n blocks, obj = self._create_blocks(self._selected_obj)\n results = []\n for b in blocks:\n result = b.notna().astype(int)\n result = self._constructor(\n result,\n window=self._get_window(),\n min_periods=self.min_periods or 0,\n center=self.center,\n axis=self.axis,\n closed=self.closed,\n ).sum()\n results.append(result)\n\n return self._wrap_results(results, obj, skipped=[])\n\n _shared_docs[\"apply\"] = dedent(\n r\"\"\"\n Apply an arbitrary function to each %(name)s window.\n\n Parameters\n ----------\n func : function\n Must produce a single value from an ndarray input if ``raw=True``\n or a single value from a Series if ``raw=False``. Can also accept a\n Numba JIT function with ``engine='numba'`` specified.\n\n .. versionchanged:: 1.0.0\n\n raw : bool, default None\n * ``False`` : passes each row or column as a Series to the\n function.\n * ``True`` : the passed function will receive ndarray\n objects instead.\n If you are just applying a NumPy reduction function this will\n achieve much better performance.\n engine : str, default None\n * ``'cython'`` : Runs rolling apply through C-extensions from cython.\n * ``'numba'`` : Runs rolling apply through JIT compiled code from numba.\n Only available when ``raw`` is set to ``True``.\n * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``\n\n .. versionadded:: 1.0.0\n\n engine_kwargs : dict, default None\n * For ``'cython'`` engine, there are no accepted ``engine_kwargs``\n * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``\n and ``parallel`` dictionary keys. The values must either be ``True`` or\n ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is\n ``{'nopython': True, 'nogil': False, 'parallel': False}`` and will be\n applied to both the ``func`` and the ``apply`` rolling aggregation.\n\n .. versionadded:: 1.0.0\n\n args : tuple, default None\n Positional arguments to be passed into func.\n kwargs : dict, default None\n Keyword arguments to be passed into func.\n\n Returns\n -------\n Series or DataFrame\n Return type is determined by the caller.\n\n See Also\n --------\n pandas.Series.%(name)s : Calling object with Series data.\n pandas.DataFrame.%(name)s : Calling object with DataFrame data.\n pandas.Series.apply : Similar method for Series.\n pandas.DataFrame.apply : Similar method for DataFrame.\n\n Notes\n -----\n See :ref:`stats.rolling_apply` for extended documentation and performance\n considerations for the Numba engine.\n \"\"\"\n )\n\n def apply(\n self,\n func,\n raw: bool = False,\n engine: Optional[str] = None,\n engine_kwargs: Optional[Dict] = None,\n args: Optional[Tuple] = None,\n kwargs: Optional[Dict] = None,\n ):\n if args is None:\n args = ()\n if kwargs is None:\n kwargs = {}\n kwargs.pop(\"_level\", None)\n kwargs.pop(\"floor\", None)\n if not is_bool(raw):\n raise ValueError(\"raw parameter must be `True` or `False`\")\n\n if maybe_use_numba(engine):\n if raw is False:\n raise ValueError(\"raw must be `True` when using the numba engine\")\n cache_key = (func, \"rolling_apply\")\n if cache_key in NUMBA_FUNC_CACHE:\n # Return an already compiled version of roll_apply if available\n apply_func = NUMBA_FUNC_CACHE[cache_key]\n else:\n apply_func = generate_numba_apply_func(\n args, kwargs, func, engine_kwargs\n )\n center = self.center\n elif engine in (\"cython\", None):\n if engine_kwargs is not None:\n raise ValueError(\"cython engine does not accept engine_kwargs\")\n # Cython apply functions handle center, so don't need to use\n # _apply's center handling\n window = self._get_window()\n offset = calculate_center_offset(window) if self.center else 0\n apply_func = self._generate_cython_apply_func(\n args, kwargs, raw, offset, func\n )\n center = False\n else:\n raise ValueError(\"engine must be either 'numba' or 'cython'\")\n\n # name=func & raw=raw for WindowGroupByMixin._apply\n return self._apply(\n apply_func,\n center=center,\n floor=0,\n name=func,\n use_numba_cache=engine == \"numba\",\n raw=raw,\n original_func=func,\n args=args,\n kwargs=kwargs,\n )\n\n def _generate_cython_apply_func(self, args, kwargs, raw, offset, func):\n from pandas import Series\n\n window_func = partial(\n self._get_cython_func_type(\"roll_generic\"),\n args=args,\n kwargs=kwargs,\n raw=raw,\n offset=offset,\n func=func,\n )\n\n def apply_func(values, begin, end, min_periods, raw=raw):\n if not raw:\n values = Series(values, index=self.obj.index)\n return window_func(values, begin, end, min_periods)\n\n return apply_func\n\n def sum(self, *args, **kwargs):\n nv.validate_window_func(\"sum\", args, kwargs)\n window_func = self._get_cython_func_type(\"roll_sum\")\n kwargs.pop(\"floor\", None)\n return self._apply(\n window_func, center=self.center, floor=0, name=\"sum\", **kwargs\n )\n\n _shared_docs[\"max\"] = dedent(\n \"\"\"\n Calculate the %(name)s maximum.\n\n Parameters\n ----------\n *args, **kwargs\n Arguments and keyword arguments to be passed into func.\n \"\"\"\n )\n\n def max(self, *args, **kwargs):\n nv.validate_window_func(\"max\", args, kwargs)\n window_func = self._get_cython_func_type(\"roll_max\")\n return self._apply(window_func, center=self.center, name=\"max\", **kwargs)\n\n _shared_docs[\"min\"] = dedent(\n \"\"\"\n Calculate the %(name)s minimum.\n\n Parameters\n ----------\n **kwargs\n Under Review.\n\n Returns\n -------\n Series or DataFrame\n Returned object type is determined by the caller of the %(name)s\n calculation.\n\n See Also\n --------\n pandas.Series.%(name)s : Calling object with a Series.\n pandas.DataFrame.%(name)s : Calling object with a DataFrame.\n pandas.Series.min : Similar method for Series.\n pandas.DataFrame.min : Similar method for DataFrame.\n\n Examples\n --------\n Performing a rolling minimum with a window size of 3.\n\n >>> s = pd.Series([4, 3, 5, 2, 6])\n >>> s.rolling(3).min()\n 0 NaN\n 1 NaN\n 2 3.0\n 3 2.0\n 4 2.0\n dtype: float64\n \"\"\"\n )\n\n def min(self, *args, **kwargs):\n nv.validate_window_func(\"min\", args, kwargs)\n window_func = self._get_cython_func_type(\"roll_min\")\n return self._apply(window_func, center=self.center, name=\"min\", **kwargs)\n\n def mean(self, *args, **kwargs):\n nv.validate_window_func(\"mean\", args, kwargs)\n window_func = self._get_cython_func_type(\"roll_mean\")\n return self._apply(window_func, center=self.center, name=\"mean\", **kwargs)\n\n _shared_docs[\"median\"] = dedent(\n \"\"\"\n Calculate the %(name)s median.\n\n Parameters\n ----------\n **kwargs\n For compatibility with other %(name)s methods. Has no effect\n on the computed median.\n\n Returns\n -------\n Series or DataFrame\n Returned type is the same as the original object.\n\n See Also\n --------\n pandas.Series.%(name)s : Calling object with Series data.\n pandas.DataFrame.%(name)s : Calling object with DataFrames.\n pandas.Series.median : Equivalent method for Series.\n pandas.DataFrame.median : Equivalent method for DataFrame.\n\n Examples\n --------\n Compute the rolling median of a series with a window size of 3.\n\n >>> s = pd.Series([0, 1, 2, 3, 4])\n >>> s.rolling(3).median()\n 0 NaN\n 1 NaN\n 2 1.0\n 3 2.0\n 4 3.0\n dtype: float64\n \"\"\"\n )\n\n def median(self, **kwargs):\n window_func = self._get_roll_func(\"roll_median_c\")\n # GH 32865. Move max window size calculation to\n # the median function implementation\n return self._apply(window_func, center=self.center, name=\"median\", **kwargs)\n\n def std(self, ddof=1, *args, **kwargs):\n nv.validate_window_func(\"std\", args, kwargs)\n kwargs.pop(\"require_min_periods\", None)\n window_func = self._get_cython_func_type(\"roll_var\")\n\n def zsqrt_func(values, begin, end, min_periods):\n return zsqrt(window_func(values, begin, end, min_periods, ddof=ddof))\n\n # ddof passed again for compat with groupby.rolling\n return self._apply(\n zsqrt_func,\n center=self.center,\n require_min_periods=1,\n name=\"std\",\n ddof=ddof,\n **kwargs,\n )\n\n def var(self, ddof=1, *args, **kwargs):\n nv.validate_window_func(\"var\", args, kwargs)\n kwargs.pop(\"require_min_periods\", None)\n window_func = partial(self._get_cython_func_type(\"roll_var\"), ddof=ddof)\n # ddof passed again for compat with groupby.rolling\n return self._apply(\n window_func,\n center=self.center,\n require_min_periods=1,\n name=\"var\",\n ddof=ddof,\n **kwargs,\n )\n\n _shared_docs[\n \"skew\"\n ] = \"\"\"\n Unbiased %(name)s skewness.\n\n Parameters\n ----------\n **kwargs\n Keyword arguments to be passed into func.\n \"\"\"\n\n def skew(self, **kwargs):\n window_func = self._get_cython_func_type(\"roll_skew\")\n kwargs.pop(\"require_min_periods\", None)\n return self._apply(\n window_func,\n center=self.center,\n require_min_periods=3,\n name=\"skew\",\n **kwargs,\n )\n\n _shared_docs[\"kurt\"] = dedent(\n \"\"\"\n Calculate unbiased %(name)s kurtosis.\n\n This function uses Fisher's definition of kurtosis without bias.\n\n Parameters\n ----------\n **kwargs\n Under Review.\n\n Returns\n -------\n Series or DataFrame\n Returned object type is determined by the caller of the %(name)s\n calculation.\n\n See Also\n --------\n pandas.Series.%(name)s : Calling object with Series data.\n pandas.DataFrame.%(name)s : Calling object with DataFrames.\n pandas.Series.kurt : Equivalent method for Series.\n pandas.DataFrame.kurt : Equivalent method for DataFrame.\n scipy.stats.skew : Third moment of a probability density.\n scipy.stats.kurtosis : Reference SciPy method.\n\n Notes\n -----\n A minimum of 4 periods is required for the %(name)s calculation.\n \"\"\"\n )\n\n def kurt(self, **kwargs):\n window_func = self._get_cython_func_type(\"roll_kurt\")\n kwargs.pop(\"require_min_periods\", None)\n return self._apply(\n window_func,\n center=self.center,\n require_min_periods=4,\n name=\"kurt\",\n **kwargs,\n )\n\n _shared_docs[\"quantile\"] = dedent(\n \"\"\"\n Calculate the %(name)s quantile.\n\n Parameters\n ----------\n quantile : float\n Quantile to compute. 0 <= quantile <= 1.\n interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}\n .. versionadded:: 0.23.0\n\n This optional parameter specifies the interpolation method to use,\n when the desired quantile lies between two data points `i` and `j`:\n\n * linear: `i + (j - i) * fraction`, where `fraction` is the\n fractional part of the index surrounded by `i` and `j`.\n * lower: `i`.\n * higher: `j`.\n * nearest: `i` or `j` whichever is nearest.\n * midpoint: (`i` + `j`) / 2.\n **kwargs\n For compatibility with other %(name)s methods. Has no effect on\n the result.\n\n Returns\n -------\n Series or DataFrame\n Returned object type is determined by the caller of the %(name)s\n calculation.\n\n See Also\n --------\n pandas.Series.quantile : Computes value at the given quantile over all data\n in Series.\n pandas.DataFrame.quantile : Computes values at the given quantile over\n requested axis in DataFrame.\n\n Examples\n --------\n >>> s = pd.Series([1, 2, 3, 4])\n >>> s.rolling(2).quantile(.4, interpolation='lower')\n 0 NaN\n 1 1.0\n 2 2.0\n 3 3.0\n dtype: float64\n\n >>> s.rolling(2).quantile(.4, interpolation='midpoint')\n 0 NaN\n 1 1.5\n 2 2.5\n 3 3.5\n dtype: float64\n \"\"\"\n )\n\n def quantile(self, quantile, interpolation=\"linear\", **kwargs):\n if quantile == 1.0:\n window_func = self._get_cython_func_type(\"roll_max\")\n elif quantile == 0.0:\n window_func = self._get_cython_func_type(\"roll_min\")\n else:\n window_func = partial(\n self._get_roll_func(\"roll_quantile\"),\n win=self._get_window(),\n quantile=quantile,\n interpolation=interpolation,\n )\n\n # Pass through for groupby.rolling\n kwargs[\"quantile\"] = quantile\n kwargs[\"interpolation\"] = interpolation\n return self._apply(window_func, center=self.center, name=\"quantile\", **kwargs)\n\n _shared_docs[\n \"cov\"\n ] = \"\"\"\n Calculate the %(name)s sample covariance.\n\n Parameters\n ----------\n other : Series, DataFrame, or ndarray, optional\n If not supplied then will default to self and produce pairwise\n output.\n pairwise : bool, default None\n If False then only matching columns between self and other will be\n used and the output will be a DataFrame.\n If True then all pairwise combinations will be calculated and the\n output will be a MultiIndexed DataFrame in the case of DataFrame\n inputs. In the case of missing elements, only complete pairwise\n observations will be used.\n ddof : int, default 1\n Delta Degrees of Freedom. The divisor used in calculations\n is ``N - ddof``, where ``N`` represents the number of elements.\n **kwargs\n Keyword arguments to be passed into func.\n \"\"\"\n\n def cov(self, other=None, pairwise=None, ddof=1, **kwargs):\n if other is None:\n other = self._selected_obj\n # only default unset\n pairwise = True if pairwise is None else pairwise\n other = self._shallow_copy(other)\n\n # GH 32865. We leverage rolling.mean, so we pass\n # to the rolling constructors the data used when constructing self:\n # window width, frequency data, or a BaseIndexer subclass\n if isinstance(self.window, BaseIndexer):\n window = self.window\n else:\n # GH 16058: offset window\n if self.is_freq_type:\n window = self.win_freq\n else:\n window = self._get_window(other)\n\n def _get_cov(X, Y):\n # GH #12373 : rolling functions error on float32 data\n # to avoid potential overflow, cast the data to float64\n X = X.astype(\"float64\")\n Y = Y.astype(\"float64\")\n mean = lambda x: x.rolling(\n window, self.min_periods, center=self.center\n ).mean(**kwargs)\n count = (\n (X + Y)\n .rolling(window=window, min_periods=0, center=self.center)\n .count(**kwargs)\n )\n bias_adj = count / (count - ddof)\n return (mean(X * Y) - mean(X) * mean(Y)) * bias_adj\n\n return _flex_binary_moment(\n self._selected_obj, other._selected_obj, _get_cov, pairwise=bool(pairwise)\n )\n\n _shared_docs[\"corr\"] = dedent(\n \"\"\"\n Calculate %(name)s correlation.\n\n Parameters\n ----------\n other : Series, DataFrame, or ndarray, optional\n If not supplied then will default to self.\n pairwise : bool, default None\n Calculate pairwise combinations of columns within a\n DataFrame. If `other` is not specified, defaults to `True`,\n otherwise defaults to `False`.\n Not relevant for :class:`~pandas.Series`.\n **kwargs\n Unused.\n\n Returns\n -------\n Series or DataFrame\n Returned object type is determined by the caller of the\n %(name)s calculation.\n\n See Also\n --------\n pandas.Series.%(name)s : Calling object with Series data.\n pandas.DataFrame.%(name)s : Calling object with DataFrames.\n pandas.Series.corr : Equivalent method for Series.\n pandas.DataFrame.corr : Equivalent method for DataFrame.\n cov : Similar method to calculate covariance.\n numpy.corrcoef : NumPy Pearson's correlation calculation.\n\n Notes\n -----\n This function uses Pearson's definition of correlation\n (https://en.wikipedia.org/wiki/Pearson_correlation_coefficient).\n\n When `other` is not specified, the output will be self correlation (e.g.\n all 1's), except for :class:`~pandas.DataFrame` inputs with `pairwise`\n set to `True`.\n\n Function will return ``NaN`` for correlations of equal valued sequences;\n this is the result of a 0/0 division error.\n\n When `pairwise` is set to `False`, only matching columns between `self` and\n `other` will be used.\n\n When `pairwise` is set to `True`, the output will be a MultiIndex DataFrame\n with the original index on the first level, and the `other` DataFrame\n columns on the second level.\n\n In the case of missing elements, only complete pairwise observations\n will be used.\n\n Examples\n --------\n The below example shows a rolling calculation with a window size of\n four matching the equivalent function call using :meth:`numpy.corrcoef`.\n\n >>> v1 = [3, 3, 3, 5, 8]\n >>> v2 = [3, 4, 4, 4, 8]\n >>> # numpy returns a 2X2 array, the correlation coefficient\n >>> # is the number at entry [0][1]\n >>> print(f\"{np.corrcoef(v1[:-1], v2[:-1])[0][1]:.6f}\")\n 0.333333\n >>> print(f\"{np.corrcoef(v1[1:], v2[1:])[0][1]:.6f}\")\n 0.916949\n >>> s1 = pd.Series(v1)\n >>> s2 = pd.Series(v2)\n >>> s1.rolling(4).corr(s2)\n 0 NaN\n 1 NaN\n 2 NaN\n 3 0.333333\n 4 0.916949\n dtype: float64\n\n The below example shows a similar rolling calculation on a\n DataFrame using the pairwise option.\n\n >>> matrix = np.array([[51., 35.], [49., 30.], [47., 32.],\\\n [46., 31.], [50., 36.]])\n >>> print(np.corrcoef(matrix[:-1,0], matrix[:-1,1]).round(7))\n [[1. 0.6263001]\n [0.6263001 1. ]]\n >>> print(np.corrcoef(matrix[1:,0], matrix[1:,1]).round(7))\n [[1. 0.5553681]\n [0.5553681 1. ]]\n >>> df = pd.DataFrame(matrix, columns=['X','Y'])\n >>> df\n X Y\n 0 51.0 35.0\n 1 49.0 30.0\n 2 47.0 32.0\n 3 46.0 31.0\n 4 50.0 36.0\n >>> df.rolling(4).corr(pairwise=True)\n X Y\n 0 X NaN NaN\n Y NaN NaN\n 1 X NaN NaN\n Y NaN NaN\n 2 X NaN NaN\n Y NaN NaN\n 3 X 1.000000 0.626300\n Y 0.626300 1.000000\n 4 X 1.000000 0.555368\n Y 0.555368 1.000000\n \"\"\"\n )\n\n def corr(self, other=None, pairwise=None, **kwargs):\n if other is None:\n other = self._selected_obj\n # only default unset\n pairwise = True if pairwise is None else pairwise\n other = self._shallow_copy(other)\n\n # GH 32865. We leverage rolling.cov and rolling.std here, so we pass\n # to the rolling constructors the data used when constructing self:\n # window width, frequency data, or a BaseIndexer subclass\n if isinstance(self.window, BaseIndexer):\n window = self.window\n else:\n window = self._get_window(other) if not self.is_freq_type else self.win_freq\n\n def _get_corr(a, b):\n a = a.rolling(\n window=window, min_periods=self.min_periods, center=self.center\n )\n b = b.rolling(\n window=window, min_periods=self.min_periods, center=self.center\n )\n\n return a.cov(b, **kwargs) / (a.std(**kwargs) * b.std(**kwargs))\n\n return _flex_binary_moment(\n self._selected_obj, other._selected_obj, _get_corr, pairwise=bool(pairwise)\n )\n\n\nclass Rolling(_Rolling_and_Expanding):\n @cache_readonly\n def is_datetimelike(self) -> bool:\n return isinstance(\n self._on, (ABCDatetimeIndex, ABCTimedeltaIndex, ABCPeriodIndex)\n )\n\n @cache_readonly\n def _on(self) -> Index:\n if self.on is None:\n if self.axis == 0:\n return self.obj.index\n else:\n # i.e. self.axis == 1\n return self.obj.columns\n elif isinstance(self.on, Index):\n return self.on\n elif isinstance(self.obj, ABCDataFrame) and self.on in self.obj.columns:\n return Index(self.obj[self.on])\n else:\n raise ValueError(\n f\"invalid on specified as {self.on}, \"\n \"must be a column (of DataFrame), an Index or None\"\n )\n\n def validate(self):\n super().validate()\n\n # we allow rolling on a datetimelike index\n if (self.obj.empty or self.is_datetimelike) and isinstance(\n self.window, (str, BaseOffset, timedelta)\n ):\n\n self._validate_monotonic()\n freq = self._validate_freq()\n\n # we don't allow center\n if self.center:\n raise NotImplementedError(\n \"center is not implemented for \"\n \"datetimelike and offset based windows\"\n )\n\n # this will raise ValueError on non-fixed freqs\n self.win_freq = self.window\n self.window = freq.nanos\n self.win_type = \"freq\"\n\n # min_periods must be an integer\n if self.min_periods is None:\n self.min_periods = 1\n\n elif isinstance(self.window, BaseIndexer):\n # Passed BaseIndexer subclass should handle all other rolling kwargs\n return\n elif not is_integer(self.window):\n raise ValueError(\"window must be an integer\")\n elif self.window < 0:\n raise ValueError(\"window must be non-negative\")\n\n if not self.is_datetimelike and self.closed is not None:\n raise ValueError(\n \"closed only implemented for datetimelike and offset based windows\"\n )\n\n def _validate_monotonic(self):\n \"\"\"\n Validate monotonic (increasing or decreasing).\n \"\"\"\n if not (self._on.is_monotonic_increasing or self._on.is_monotonic_decreasing):\n formatted = self.on\n if self.on is None:\n formatted = \"index\"\n raise ValueError(f\"{formatted} must be monotonic\")\n\n def _validate_freq(self):\n \"\"\"\n Validate & return window frequency.\n \"\"\"\n try:\n return to_offset(self.window)\n except (TypeError, ValueError) as err:\n raise ValueError(\n f\"passed window {self.window} is not \"\n \"compatible with a datetimelike index\"\n ) from err\n\n _agg_see_also_doc = dedent(\n \"\"\"\n See Also\n --------\n pandas.Series.rolling : Calling object with Series data.\n pandas.DataFrame.rolling : Calling object with DataFrame data.\n \"\"\"\n )\n\n _agg_examples_doc = dedent(\n \"\"\"\n Examples\n --------\n >>> df = pd.DataFrame({\"A\": [1, 2, 3], \"B\": [4, 5, 6], \"C\": [7, 8, 9]})\n >>> df\n A B C\n 0 1 4 7\n 1 2 5 8\n 2 3 6 9\n\n >>> df.rolling(2).sum()\n A B C\n 0 NaN NaN NaN\n 1 3.0 9.0 15.0\n 2 5.0 11.0 17.0\n\n >>> df.rolling(2).agg({\"A\": \"sum\", \"B\": \"min\"})\n A B\n 0 NaN NaN\n 1 3.0 4.0\n 2 5.0 5.0\n \"\"\"\n )\n\n @doc(\n _shared_docs[\"aggregate\"],\n see_also=_agg_see_also_doc,\n examples=_agg_examples_doc,\n versionadded=\"\",\n klass=\"Series/Dataframe\",\n axis=\"\",\n )\n def aggregate(self, func, *args, **kwargs):\n return super().aggregate(func, *args, **kwargs)\n\n agg = aggregate\n\n @Substitution(name=\"rolling\")\n @Appender(_shared_docs[\"count\"])\n def count(self):\n\n # different impl for freq counting\n # GH 32865. Use a custom count function implementation\n # when using a BaseIndexer subclass as a window\n if self.is_freq_type or isinstance(self.window, BaseIndexer):\n window_func = self._get_roll_func(\"roll_count\")\n return self._apply(window_func, center=self.center, name=\"count\")\n\n return super().count()\n\n @Substitution(name=\"rolling\")\n @Appender(_shared_docs[\"apply\"])\n def apply(\n self, func, raw=False, engine=None, engine_kwargs=None, args=None, kwargs=None,\n ):\n return super().apply(\n func,\n raw=raw,\n engine=engine,\n engine_kwargs=engine_kwargs,\n args=args,\n kwargs=kwargs,\n )\n\n @Substitution(name=\"rolling\")\n @Appender(_shared_docs[\"sum\"])\n def sum(self, *args, **kwargs):\n nv.validate_rolling_func(\"sum\", args, kwargs)\n return super().sum(*args, **kwargs)\n\n @Substitution(name=\"rolling\", func_name=\"max\")\n @Appender(_doc_template)\n @Appender(_shared_docs[\"max\"])\n def max(self, *args, **kwargs):\n nv.validate_rolling_func(\"max\", args, kwargs)\n return super().max(*args, **kwargs)\n\n @Substitution(name=\"rolling\")\n @Appender(_shared_docs[\"min\"])\n def min(self, *args, **kwargs):\n nv.validate_rolling_func(\"min\", args, kwargs)\n return super().min(*args, **kwargs)\n\n @Substitution(name=\"rolling\")\n @Appender(_shared_docs[\"mean\"])\n def mean(self, *args, **kwargs):\n nv.validate_rolling_func(\"mean\", args, kwargs)\n return super().mean(*args, **kwargs)\n\n @Substitution(name=\"rolling\")\n @Appender(_shared_docs[\"median\"])\n def median(self, **kwargs):\n return super().median(**kwargs)\n\n @Substitution(name=\"rolling\", versionadded=\"\")\n @Appender(_shared_docs[\"std\"])\n def std(self, ddof=1, *args, **kwargs):\n nv.validate_rolling_func(\"std\", args, kwargs)\n return super().std(ddof=ddof, **kwargs)\n\n @Substitution(name=\"rolling\", versionadded=\"\")\n @Appender(_shared_docs[\"var\"])\n def var(self, ddof=1, *args, **kwargs):\n nv.validate_rolling_func(\"var\", args, kwargs)\n return super().var(ddof=ddof, **kwargs)\n\n @Substitution(name=\"rolling\", func_name=\"skew\")\n @Appender(_doc_template)\n @Appender(_shared_docs[\"skew\"])\n def skew(self, **kwargs):\n return super().skew(**kwargs)\n\n _agg_doc = dedent(\n \"\"\"\n Examples\n --------\n\n The example below will show a rolling calculation with a window size of\n four matching the equivalent function call using `scipy.stats`.\n\n >>> arr = [1, 2, 3, 4, 999]\n >>> import scipy.stats\n >>> print(f\"{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}\")\n -1.200000\n >>> print(f\"{scipy.stats.kurtosis(arr[1:], bias=False):.6f}\")\n 3.999946\n >>> s = pd.Series(arr)\n >>> s.rolling(4).kurt()\n 0 NaN\n 1 NaN\n 2 NaN\n 3 -1.200000\n 4 3.999946\n dtype: float64\n \"\"\"\n )\n\n @Appender(_agg_doc)\n @Substitution(name=\"rolling\")\n @Appender(_shared_docs[\"kurt\"])\n def kurt(self, **kwargs):\n return super().kurt(**kwargs)\n\n @Substitution(name=\"rolling\")\n @Appender(_shared_docs[\"quantile\"])\n def quantile(self, quantile, interpolation=\"linear\", **kwargs):\n return super().quantile(\n quantile=quantile, interpolation=interpolation, **kwargs\n )\n\n @Substitution(name=\"rolling\", func_name=\"cov\")\n @Appender(_doc_template)\n @Appender(_shared_docs[\"cov\"])\n def cov(self, other=None, pairwise=None, ddof=1, **kwargs):\n return super().cov(other=other, pairwise=pairwise, ddof=ddof, **kwargs)\n\n @Substitution(name=\"rolling\")\n @Appender(_shared_docs[\"corr\"])\n def corr(self, other=None, pairwise=None, **kwargs):\n return super().corr(other=other, pairwise=pairwise, **kwargs)\n\n\nRolling.__doc__ = Window.__doc__\n\n\nclass RollingGroupby(WindowGroupByMixin, Rolling):\n \"\"\"\n Provide a rolling groupby implementation.\n \"\"\"\n\n def _apply(\n self,\n func: Callable,\n center: bool,\n require_min_periods: int = 0,\n floor: int = 1,\n is_weighted: bool = False,\n name: Optional[str] = None,\n use_numba_cache: bool = False,\n **kwargs,\n ):\n result = Rolling._apply(\n self,\n func,\n center,\n require_min_periods,\n floor,\n is_weighted,\n name,\n use_numba_cache,\n **kwargs,\n )\n # Cannot use _wrap_outputs because we calculate the result all at once\n # Compose MultiIndex result from grouping levels then rolling level\n # Aggregate the MultiIndex data as tuples then the level names\n grouped_object_index = self.obj.index\n grouped_index_name = [grouped_object_index.name]\n groupby_keys = [grouping.name for grouping in self._groupby.grouper._groupings]\n result_index_names = groupby_keys + grouped_index_name\n\n result_index_data = []\n for key, values in self._groupby.grouper.indices.items():\n for value in values:\n if not is_list_like(key):\n data = [key, grouped_object_index[value]]\n else:\n data = [*key, grouped_object_index[value]]\n result_index_data.append(tuple(data))\n\n result_index = MultiIndex.from_tuples(\n result_index_data, names=result_index_names\n )\n result.index = result_index\n return result\n\n @property\n def _constructor(self):\n return Rolling\n\n def _create_blocks(self, obj: FrameOrSeriesUnion):\n \"\"\"\n Split data into blocks & return conformed data.\n \"\"\"\n # Ensure the object we're rolling over is monotonically sorted relative\n # to the groups\n groupby_order = np.concatenate(\n list(self._groupby.grouper.indices.values())\n ).astype(np.int64)\n obj = obj.take(groupby_order)\n return super()._create_blocks(obj)\n\n def _get_cython_func_type(self, func: str) -> Callable:\n \"\"\"\n Return the cython function type.\n\n RollingGroupby needs to always use \"variable\" algorithms since processing\n the data in group order may not be monotonic with the data which\n \"fixed\" algorithms assume\n \"\"\"\n return self._get_roll_func(f\"{func}_variable\")\n\n def _get_window_indexer(self, window: int) -> GroupbyRollingIndexer:\n \"\"\"\n Return an indexer class that will compute the window start and end bounds\n\n Parameters\n ----------\n window : int\n window size for FixedWindowIndexer\n\n Returns\n -------\n GroupbyRollingIndexer\n \"\"\"\n rolling_indexer: Type[BaseIndexer]\n indexer_kwargs: Optional[Dict] = None\n index_array = self.obj.index.asi8\n if isinstance(self.window, BaseIndexer):\n rolling_indexer = type(self.window)\n indexer_kwargs = self.window.__dict__\n assert isinstance(indexer_kwargs, dict) # for mypy\n # We'll be using the index of each group later\n indexer_kwargs.pop(\"index_array\", None)\n elif self.is_freq_type:\n rolling_indexer = VariableWindowIndexer\n else:\n rolling_indexer = FixedWindowIndexer\n index_array = None\n window_indexer = GroupbyRollingIndexer(\n index_array=index_array,\n window_size=window,\n groupby_indicies=self._groupby.indices,\n rolling_indexer=rolling_indexer,\n indexer_kwargs=indexer_kwargs,\n )\n return window_indexer\n\n def _gotitem(self, key, ndim, subset=None):\n # we are setting the index on the actual object\n # here so our index is carried thru to the selected obj\n # when we do the splitting for the groupby\n if self.on is not None:\n self.obj = self.obj.set_index(self._on)\n self.on = None\n return super()._gotitem(key, ndim, subset=subset)\n\n def _validate_monotonic(self):\n \"\"\"\n Validate that on is monotonic;\n we don't care for groupby.rolling\n because we have already validated at a higher\n level.\n \"\"\"\n pass\n"
] |
[
[
"pandas.core.window.indexers.FixedWindowIndexer",
"pandas.core.common.asarray_tuplesafe",
"numpy.where",
"pandas.core.construction.extract_array",
"pandas.core.window.indexers.GroupbyRollingIndexer",
"numpy.apply_along_axis",
"pandas.core.dtypes.common.is_float_dtype",
"pandas.concat",
"pandas.core.base.DataError",
"numpy.concatenate",
"pandas.core.indexes.api.Index",
"pandas.compat.numpy.function.validate_rolling_func",
"pandas.core.dtypes.common.is_bool",
"pandas.core.dtypes.common.is_integer_dtype",
"pandas.core.indexes.api.MultiIndex.from_tuples",
"pandas.util._decorators.Appender",
"pandas.util._decorators.Substitution",
"numpy.array",
"pandas._libs.tslibs.to_offset",
"pandas.core.dtypes.common.is_scalar",
"pandas.util._decorators.doc",
"pandas.core.dtypes.common.is_integer",
"pandas.compat.numpy.function.validate_window_func",
"pandas.core.util.numba_.maybe_use_numba",
"pandas.core.window.indexers.VariableWindowIndexer",
"pandas.core.dtypes.common.is_list_like",
"numpy.isinf",
"pandas.core.window.indexers.BaseIndexer",
"numpy.asarray",
"numpy.errstate",
"pandas.compat._optional.import_optional_dependency",
"pandas.core.dtypes.common.ensure_float64",
"scipy.signal.get_window",
"pandas.Series",
"pandas.core.dtypes.common.needs_i8_conversion",
"pandas.core.window.numba_.generate_numba_apply_func"
]
] |
kowshikthopalli/MULDENS
|
[
"e2d5f8ec51024c5bdda6d1fcde4a96a3f31e6930"
] |
[
"domainbed/scripts/dson.py"
] |
[
"import argparse\nimport collections\nimport json\nimport os\nimport random\nimport sys\nimport time\nimport uuid\n#sys.path.append('/home/kowshik/infoDG')\nimport numpy as np\nimport PIL\nimport torch\nimport torchvision\nimport torch.utils.data\nimport torch.nn as nn\n\n\n\n\nclass OptimizedNorm2d(nn.Module):\n def __init__(self, num_features, eps=1e-5, momentum=0.9, using_moving_average=True,\n last_gamma=False, channelwise=False, modes=['in', 'bn']):\n super(OptimizedNorm2d, self).__init__()\n self.eps = eps\n self.momentum = momentum\n self.using_moving_average = using_moving_average\n self.last_gamma = last_gamma\n self.weight = nn.Parameter(torch.ones(1, num_features, 1, 1))\n self.bias = nn.Parameter(torch.zeros(1, num_features, 1, 1))\n self.channelwise = channelwise\n self.num_features = num_features\n self.modes = modes\n\n num_norms = len(modes)\n if channelwise:\n self.mean_weight = nn.Parameter(torch.ones(num_norms, num_features))\n self.var_weight = nn.Parameter(torch.ones(num_norms, num_features))\n else:\n self.mean_weight = nn.Parameter(torch.ones(num_norms))\n self.var_weight = nn.Parameter(torch.ones(num_norms))\n\n self.register_buffer('running_mean', torch.zeros(1, num_features, 1))\n self.register_buffer('running_var', torch.zeros(1, num_features, 1))\n\n self.reset_parameters()\n\n def reset_parameters(self):\n self.running_mean.zero_()\n self.running_var.zero_()\n if self.last_gamma:\n self.weight.data.fill_(0)\n else:\n self.weight.data.fill_(1)\n self.bias.data.zero_()\n\n def _check_input_dim(self, input):\n if input.dim() != 4:\n raise ValueError('expected 4D input (got {}D input)'\n .format(input.dim()))\n\n def get_norm_ratios(self, mean=False):\n softmax = nn.Softmax(0)\n mean_weight, var_weight = self.mean_weight, self.var_weight\n mean_weight, var_weight = softmax(mean_weight), softmax(var_weight)\n return mean_weight, var_weight\n\n def forward(self, input):\n self._check_input_dim(input)\n N, C, H, W = input.size()\n x = input.view(N, C, -1)\n \n mean_in = x.mean(-1, keepdim=True)\n var_in = x.var(-1, keepdim=True)\n temp = var_in + mean_in ** 2\n\n if self.training:\n mean_bn = mean_in.mean(0, keepdim=True)\n var_bn = temp.mean(0, keepdim=True) - mean_bn ** 2\n if self.using_moving_average:\n self.running_mean.mul_(self.momentum)\n self.running_mean.add_((1 - self.momentum) * mean_bn.data)\n self.running_var.mul_(self.momentum)\n self.running_var.add_((1 - self.momentum) * var_bn.data)\n else:\n self.running_mean.add_(mean_bn.data)\n self.running_var.add_(mean_bn.data ** 2 + var_bn.data)\n else:\n mean_bn = torch.autograd.Variable(self.running_mean)\n var_bn = torch.autograd.Variable(self.running_var)\n\n\n mean_weight, var_weight = self.get_norm_ratios()\n\n mean_norms = {'in': mean_in, 'bn': mean_bn}\n var_norms = {'in': var_in, 'bn': var_bn}\n\n mean = sum([mean_norms[mode]*mw for mode, mw in zip(self.modes, mean_weight)])\n var = sum([var_norms[mode]*mw for mode, mw in zip(self.modes, var_weight)])\n\n x = (x-mean) / (var+self.eps).sqrt()\n x = x.view(N, C, H, W)\n return x * self.weight + self.bias\n\n\n \nclass DomainSpecificOptimizedNorm2d(nn.Module):\n def __init__(self, num_features, num_domains, eps=1e-5, momentum=0.9, using_moving_average=True, using_bn=True,\n last_gamma=False, module='OptimizedNorm2d'):\n\n super(DomainSpecificOptimizedNorm2d, self).__init__()\n\n self.bns = nn.ModuleList(\n [globals()[module](num_features, eps, momentum) for _ in range(num_domains)]\n )\n\n def reset_running_stats(self):\n for bn in self.bns:\n bn.reset_running_stats()\n\n def reset_parameters(self):\n for bn in self.bns:\n bn.reset_parameters()\n\n def _check_input_dim(self, input):\n if input.dim() != 4:\n raise ValueError('expected 4D input (got {}D input)'\n .format(input.dim()))\n\n def forward(self, x, domain_label):\n self._check_input_dim(x)\n bn = self.bns[domain_label]\n return bn(x), domain_label\n\n\n\n\n\n\n\nif __name__ == \"__main__\":\n\n dson = DomainSpecificOptimizedNorm2d(3,3,)\n x = torch.zeros(10,3,224, 224)\n dson(x,0).shape"
] |
[
[
"torch.zeros",
"torch.autograd.Variable",
"torch.nn.Softmax",
"torch.ones"
]
] |
takumak/tuna
|
[
"a50d1d34c9917d73f02257bcffcf7cc6bf582747"
] |
[
"src/interpolation.py"
] |
[
"import numpy as np\n\nfrom settingobj import SettingObj\nfrom settingitems import *\nfrom commonwidgets import *\n\n\n\n__all__ = ['InterpLinear', 'InterpBSpline',\n 'InterpCubicSpline', 'InterpBarycentric',\n 'InterpKrogh', 'InterpPchip', 'InterpAkima']\n\n\n\nclass InterpBase(SettingObj):\n def func(self, x, y):\n raise NotImplementedError()\n\n\n\nclass InterpLinear(InterpBase):\n name = 'linear'\n label = 'Linear'\n\n def func(self, x, y):\n from scipy.interpolate import interp1d\n return interp1d(x, y, 'linear')\n\n def descriptionWidget(self):\n w = DescriptionWidget()\n w.addTitle(self.label)\n url = 'https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html'\n w.addLabel('''\nThis runs <code>scipy.interpolate.interp1d(x, y, \"linear\")</code>.<br>\n<a href=\"{0}\">{0}</a>\n'''.format(url).strip(), richtext=True)\n return w\n\n\n\nclass InterpBSpline(InterpBase):\n name = 'b_spline'\n label = 'B-spline'\n\n def __init__(self):\n super().__init__()\n self.addSettingItem(SettingItemStr('w', 'Weight (function of x,y)', '1/(ymax*0.003*(1.00001-y/ymax))'))\n\n def func(self, x, y):\n from sympy import sympify, lambdify\n from scipy.interpolate import splrep, splev\n w = lambdify(['x', 'y', 'ymax'], sympify(self.w.strValue()), 'numpy')(x, y, np.full(len(x), max(y)))\n try:\n iter(w)\n except:\n w = np.full(x.shape, w)\n\n c = len(x)//10\n xl = np.linspace(x[0]+(x[0]-x[1])*c, x[0], c, endpoint=False)\n xr = np.flip(np.linspace(x[-1]+(x[-1]-x[-2])*c, x[-1], c, endpoint=False), 0)\n x2 = np.concatenate((xl, x, xr))\n y2 = np.concatenate((np.full(c, y[0]), y, np.full(c, y[-1])))\n w2 = np.concatenate((np.full(c, w[0]), w, np.full(c, w[-1])))\n spl = splrep(x2, y2, w=w2)\n return lambda x: splev(x, spl)\n\n\n\nclass InterpScipy(InterpBase):\n def func(self, x, y):\n import scipy.interpolate as interp\n return getattr(interp, self.clsname)(x, y)\n\n def descriptionWidget(self):\n modname = 'scipy.interpolate.%s' % self.clsname\n w = DescriptionWidget()\n w.addTitle(self.label)\n url = 'https://docs.scipy.org/doc/scipy/reference/generated/%s.html' % modname\n w.addLabel('''\nThis uses <code>{0}</code>.<br>\n<a href=\"{1}\">{1}</a>\n'''.format(modname, url).strip(), richtext=True)\n return w\n\nclass InterpCubicSpline(InterpScipy):\n name = 'cubic_spline'\n label = 'Cubic spline'\n clsname = 'CubicSpline'\n\nclass InterpBarycentric(InterpScipy):\n name = 'barycentric'\n label = 'Barycentric'\n clsname = 'BarycentricInterpolator'\n\nclass InterpKrogh(InterpScipy):\n name = 'krogh'\n label = 'Krogh'\n clsname = 'KroghInterpolator'\n\nclass InterpPchip(InterpScipy):\n name = 'pchip'\n label = 'Pchip'\n clsname = 'PchipInterpolator'\n\nclass InterpAkima(InterpScipy):\n name = 'akima'\n label = 'Akima'\n clsname = 'Akima1DInterpolator'\n"
] |
[
[
"numpy.concatenate",
"numpy.full",
"scipy.interpolate.interp1d",
"scipy.interpolate.splrep",
"scipy.interpolate.splev",
"numpy.linspace"
]
] |
eleflea/tvm
|
[
"d199243d8907b2d8062dd9c20b69dcb9765a970f",
"d199243d8907b2d8062dd9c20b69dcb9765a970f",
"d199243d8907b2d8062dd9c20b69dcb9765a970f"
] |
[
"tutorials/frontend/from_tflite.py",
"tutorials/language/extern_op.py",
"tests/python/unittest/test_auto_scheduler_layout_rewrite.py"
] |
[
"# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\"\"\"\nCompile TFLite Models\n=====================\n**Author**: `Zhao Wu <https://github.com/FrozenGene>`_\n\nThis article is an introductory tutorial to deploy TFLite models with Relay.\n\nTo get started, TFLite package needs to be installed as prerequisite.\n\n.. code-block:: bash\n\n # install tflite\n pip install tflite==2.1.0 --user\n\n\nor you could generate TFLite package yourself. The steps are the following:\n\n.. code-block:: bash\n\n # Get the flatc compiler.\n # Please refer to https://github.com/google/flatbuffers for details\n # and make sure it is properly installed.\n flatc --version\n\n # Get the TFLite schema.\n wget https://raw.githubusercontent.com/tensorflow/tensorflow/r1.13/tensorflow/lite/schema/schema.fbs\n\n # Generate TFLite package.\n flatc --python schema.fbs\n\n # Add current folder (which contains generated tflite module) to PYTHONPATH.\n export PYTHONPATH=${PYTHONPATH:+$PYTHONPATH:}$(pwd)\n\n\nNow please check if TFLite package is installed successfully, ``python -c \"import tflite\"``\n\nBelow you can find an example on how to compile TFLite model using TVM.\n\"\"\"\n######################################################################\n# Utils for downloading and extracting zip files\n# ----------------------------------------------\nimport os\n\n\ndef extract(path):\n import tarfile\n\n if path.endswith(\"tgz\") or path.endswith(\"gz\"):\n dir_path = os.path.dirname(path)\n tar = tarfile.open(path)\n tar.extractall(path=dir_path)\n tar.close()\n else:\n raise RuntimeError(\"Could not decompress the file: \" + path)\n\n\n######################################################################\n# Load pretrained TFLite model\n# ----------------------------\n# Load mobilenet V1 TFLite model provided by Google\nfrom tvm.contrib.download import download_testdata\n\nmodel_url = \"http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_1.0_224.tgz\"\n\n# Download model tar file and extract it to get mobilenet_v1_1.0_224.tflite\nmodel_path = download_testdata(model_url, \"mobilenet_v1_1.0_224.tgz\", module=[\"tf\", \"official\"])\nmodel_dir = os.path.dirname(model_path)\nextract(model_path)\n\n# Now we can open mobilenet_v1_1.0_224.tflite\ntflite_model_file = os.path.join(model_dir, \"mobilenet_v1_1.0_224.tflite\")\ntflite_model_buf = open(tflite_model_file, \"rb\").read()\n\n# Get TFLite model from buffer\ntry:\n import tflite\n\n tflite_model = tflite.Model.GetRootAsModel(tflite_model_buf, 0)\nexcept AttributeError:\n import tflite.Model\n\n tflite_model = tflite.Model.Model.GetRootAsModel(tflite_model_buf, 0)\n\n######################################################################\n# Load a test image\n# -----------------\n# A single cat dominates the examples!\nfrom PIL import Image\nfrom matplotlib import pyplot as plt\nimport numpy as np\n\nimage_url = \"https://github.com/dmlc/mxnet.js/blob/main/data/cat.png?raw=true\"\nimage_path = download_testdata(image_url, \"cat.png\", module=\"data\")\nresized_image = Image.open(image_path).resize((224, 224))\nplt.imshow(resized_image)\nplt.show()\nimage_data = np.asarray(resized_image).astype(\"float32\")\n\n# Add a dimension to the image so that we have NHWC format layout\nimage_data = np.expand_dims(image_data, axis=0)\n\n# Preprocess image as described here:\n# https://github.com/tensorflow/models/blob/edb6ed22a801665946c63d650ab9a0b23d98e1b1/research/slim/preprocessing/inception_preprocessing.py#L243\nimage_data[:, :, :, 0] = 2.0 / 255.0 * image_data[:, :, :, 0] - 1\nimage_data[:, :, :, 1] = 2.0 / 255.0 * image_data[:, :, :, 1] - 1\nimage_data[:, :, :, 2] = 2.0 / 255.0 * image_data[:, :, :, 2] - 1\nprint(\"input\", image_data.shape)\n\n######################################################################\n# Compile the model with relay\n# ----------------------------\n\n# TFLite input tensor name, shape and type\ninput_tensor = \"input\"\ninput_shape = (1, 224, 224, 3)\ninput_dtype = \"float32\"\n\n# Parse TFLite model and convert it to a Relay module\nfrom tvm import relay, transform\n\nmod, params = relay.frontend.from_tflite(\n tflite_model, shape_dict={input_tensor: input_shape}, dtype_dict={input_tensor: input_dtype}\n)\n\n# Build the module against to x86 CPU\ntarget = \"llvm\"\nwith transform.PassContext(opt_level=3):\n lib = relay.build(mod, target, params=params)\n\n######################################################################\n# Execute on TVM\n# --------------\nimport tvm\nfrom tvm import te\nfrom tvm.contrib import graph_runtime as runtime\n\n# Create a runtime executor module\nmodule = runtime.GraphModule(lib[\"default\"](tvm.cpu()))\n\n# Feed input data\nmodule.set_input(input_tensor, tvm.nd.array(image_data))\n\n# Run\nmodule.run()\n\n# Get output\ntvm_output = module.get_output(0).asnumpy()\n\n######################################################################\n# Display results\n# ---------------\n\n# Load label file\nlabel_file_url = \"\".join(\n [\n \"https://raw.githubusercontent.com/\",\n \"tensorflow/tensorflow/master/tensorflow/lite/java/demo/\",\n \"app/src/main/assets/\",\n \"labels_mobilenet_quant_v1_224.txt\",\n ]\n)\nlabel_file = \"labels_mobilenet_quant_v1_224.txt\"\nlabel_path = download_testdata(label_file_url, label_file, module=\"data\")\n\n# List of 1001 classes\nwith open(label_path) as f:\n labels = f.readlines()\n\n# Convert result to 1D data\npredictions = np.squeeze(tvm_output)\n\n# Get top 1 prediction\nprediction = np.argmax(predictions)\n\n# Convert id to class name and show the result\nprint(\"The image prediction result is: id \" + str(prediction) + \" name: \" + labels[prediction])\n",
"# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\"\"\"\nExternal Tensor Functions\n=========================\n**Author**: `Tianqi Chen <https://tqchen.github.io>`_\n\nWhile TVM supports transparent code generation, sometimes\nit is also helpful to incorporate manual written code into\nthe pipeline. For example, we might want to use cuDNN for\nsome of the convolution kernels and define the rest of the stages.\n\nTVM supports these black box function calls natively.\nSpecfically, TVM support all the tensor functions that are DLPack compatible.\nWhich means we can call any function with POD types(pointer, int, float)\nor pointer to DLTensor as argument.\n\"\"\"\nfrom __future__ import absolute_import, print_function\n\nimport tvm\nfrom tvm import te\nimport numpy as np\nfrom tvm.contrib import cblas\nimport tvm.testing\n\nif not tvm.get_global_func(\"tvm.contrib.cblas.matmul\", allow_missing=True):\n raise Exception(\"Not compiled with cblas support; can't build this tutorial\")\n\n######################################################################\n# Use Extern Tensor Function\n# --------------------------\n# In the example below, we use :any:`te.extern` to add an extern\n# array function call. In the extern call, we declare the shape\n# of output tensors. In the second argument we provide the list of inputs.\n#\n# User will need to provide a function describing how to compute the result.\n# The compute function takes list of symbolic placeholder for the inputs,\n# list of symbolic placeholder for the outputs and returns the executing statement.\n#\n# In this case we simply call a registered TVM function, which invokes a CBLAS call.\n# TVM does not control internal of the extern array function and treats it as blackbox.\n# We can further mix schedulable TVM calls that add a bias term to the result.\n#\nn = 1024\nl = 128\nm = 235\nbias = te.var(\"bias\", dtype=\"float32\")\nA = te.placeholder((n, l), name=\"A\")\nB = te.placeholder((l, m), name=\"B\")\nC = te.extern(\n (n, m),\n [A, B],\n lambda ins, outs: tvm.tir.call_packed(\n \"tvm.contrib.cblas.matmul\", ins[0], ins[1], outs[0], False, False\n ),\n name=\"C\",\n)\nD = te.compute(C.shape, lambda i, j: C[i, j] + bias, name=\"D\")\ns = te.create_schedule(D.op)\n\n######################################################################\n# Verify the Result\n# -----------------\n# We can verify that the result matches what we expected.\n#\nctx = tvm.cpu(0)\nf = tvm.build(s, [A, B, D, bias], \"llvm\")\na = tvm.nd.array(np.random.uniform(size=(n, l)).astype(A.dtype), ctx)\nb = tvm.nd.array(np.random.uniform(size=(l, m)).astype(B.dtype), ctx)\nd = tvm.nd.array(np.zeros((n, m), dtype=D.dtype), ctx)\nbb = 10.0\nf(a, b, d, bb)\ntvm.testing.assert_allclose(d.asnumpy(), np.dot(a.asnumpy(), b.asnumpy()) + 10, rtol=1e-5)\n\n######################################################################\n# Extern Contrib Wrappers\n# -----------------------\n# TVM also provide extern contrib wrappers to useful extern calls,\n# the following line is equivalent to the previous example.\n#\nfrom tvm.contrib import cblas\n\nC = cblas.matmul(A, B)\nD = te.compute(C.shape, lambda i, j: C[i, j] + bias, name=\"D\")\ns = te.create_schedule(D.op)\n\n######################################################################\n# Hook Python Function as Extern\n# ------------------------------\n# Since we can call into any PackedFunc in TVM. We can use the extern\n# function to callback into python.\n#\n# The following example registers a python function into TVM runtime system\n# and use it to complete one stage of the computation.\n# This makes TVM much more flexible. For example, we can insert front-end\n# callbacks to inspect the intermediate results or mix customized code\n# with TVM.\n#\n@tvm.register_func(\"tvm.contrib.my_tvm_addone\")\ndef my_tvm_addone(x, y):\n print(\"my_tvm_addone signatures: %s, %s\" % (type(x), type(y)))\n tvm.nd.array(x.asnumpy() + 1).copyto(y)\n\n\nA = te.placeholder((n,), name=\"A\")\nB = te.extern(\n A.shape,\n [A],\n lambda ins, outs: tvm.tir.call_packed(\"tvm.contrib.my_tvm_addone\", ins[0], outs[0]),\n name=\"C\",\n)\ns = te.create_schedule(B.op)\nf = tvm.build(s, [A, B], \"llvm\")\na = tvm.nd.array(np.random.uniform(size=(n,)).astype(A.dtype), ctx)\nb = tvm.nd.array(np.random.uniform(size=(n,)).astype(B.dtype), ctx)\nf(a, b)\ntvm.testing.assert_allclose(b.asnumpy(), a.asnumpy() + 1, rtol=1e-5)\n\n######################################################################\n# Summary\n# -------\n# - TVM calls extern tensor function via :any:`te.extern`\n# - Use contrib wrappers for short sugars of extern tensor calls.\n# - We can hook front-end function as extern tensor callbacks.\n#\n",
"# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\n\"\"\"Test AutoScheduler Layout Rewrite\"\"\"\nimport tempfile\nimport numpy as np\n\nimport pytest\n\nimport tvm\nimport tvm.testing\nfrom tvm import topi\nfrom tvm import auto_scheduler, te\n\nfrom test_auto_scheduler_common import get_tiled_matmul, matmul_auto_scheduler_test\n\n\ndef test_apply_steps_with_layout_rewrite():\n dag, s = get_tiled_matmul()\n _, bufs = dag.apply_steps_from_state(s)\n assert bufs[1].shape[0] == 512\n assert bufs[1].shape[1] == 512\n _, bufs = dag.apply_steps_from_state(\n s, layout_rewrite=auto_scheduler.LayoutRewriteOption.REWRITE_FOR_PRE_TRANSFORMED\n )\n assert bufs[1].shape[0] == 4\n assert bufs[1].shape[1] == 8\n assert bufs[1].shape[2] == 4\n assert bufs[1].shape[3] == 4\n assert bufs[1].shape[4] == 512\n _, bufs = dag.apply_steps_from_state(\n s, layout_rewrite=auto_scheduler.LayoutRewriteOption.INSERT_TRANSFORM_STAGE\n )\n assert bufs[1].shape[0] == 512\n assert bufs[1].shape[1] == 512\n\n\ndef test_apply_steps_with_layout_rewrite_corner_case():\n A, B, C = matmul_auto_scheduler_test(1, 1, 1)\n dag = auto_scheduler.ComputeDAG([A, B, C])\n\n s = dag.get_init_state()\n\n s.compute_root(C)\n i_j_fused = s.fuse(C, [s[C].iters[0], s[C].iters[1]])\n s.parallel(C, i_j_fused)\n\n _, bufs = dag.apply_steps_from_state(\n s, layout_rewrite=auto_scheduler.LayoutRewriteOption.REWRITE_FOR_PRE_TRANSFORMED\n )\n\n\n@tvm.testing.requires_llvm\ndef test_correctness_layout_rewrite_rewrite_for_preTransformed():\n N = 16\n target = tvm.target.Target(\"llvm\")\n task = auto_scheduler.SearchTask(func=matmul_auto_scheduler_test, args=(N, N, N), target=target)\n dag = task.compute_dag\n\n with tempfile.NamedTemporaryFile() as fp:\n log_file = fp.name\n\n search_policy = auto_scheduler.SketchPolicy(task)\n\n measure_ctx = auto_scheduler.LocalRPCMeasureContext()\n tuning_options = auto_scheduler.TuningOptions(\n num_measure_trials=100,\n runner=measure_ctx.runner,\n verbose=2,\n early_stopping=1,\n measure_callbacks=[auto_scheduler.RecordToFile(log_file)],\n )\n task.tune(tuning_options, search_policy=search_policy)\n inp, _ = auto_scheduler.load_best_record(log_file, task.workload_key, target)\n s, bufs = dag.apply_steps_from_state(\n inp.state, layout_rewrite=auto_scheduler.LayoutRewriteOption.REWRITE_FOR_PRE_TRANSFORMED\n )\n s_ref, bufs_ref = dag.apply_steps_from_state(inp.state)\n np_args = [np.random.randn(*topi.get_const_tuple(x.shape)).astype(x.dtype) for x in bufs]\n np_args_ref = [np.array(x) for x in np_args]\n\n weight = np_args_ref[1]\n # infer shape for the rewritten layout\n if len(weight.shape) >= 6:\n # For cpu tile structure SSRSRS\n base = len(weight.shape) - 6\n red_dim = weight.shape[2 + base] * weight.shape[4 + base]\n out_dim = weight.shape[3 + base] * weight.shape[5 + base]\n for i in range(base + 2):\n out_dim *= weight.shape[i]\n new_order = (\n [\n 2 + base,\n 4 + base,\n ]\n + list(range(base + 2))\n + [\n 3 + base,\n 5 + base,\n ]\n )\n np_args_ref[1] = np_args_ref[1].transpose(new_order)\n np_args_ref[1] = np_args_ref[1].reshape((red_dim, out_dim))\n\n func = tvm.build(s, bufs, target=target)\n func_ref = tvm.build(s_ref, bufs_ref, target=target)\n\n ctx = tvm.context(str(target))\n ctx_ref = tvm.cpu()\n\n args = [tvm.nd.array(x, ctx=ctx) for x in np_args]\n args_ref = [tvm.nd.array(x, ctx=ctx_ref) for x in np_args_ref]\n ctx.sync()\n\n func(*args)\n func_ref(*args_ref)\n ctx.sync()\n\n tvm.testing.assert_allclose(args[0].asnumpy(), args_ref[0].asnumpy(), atol=1e-3, rtol=1e-3)\n tvm.testing.assert_allclose(args[2].asnumpy(), args_ref[2].asnumpy(), atol=1e-3, rtol=1e-3)\n del measure_ctx\n\n\n@tvm.testing.requires_llvm\ndef test_correctness_layout_rewrite_insert_transform_stage():\n N = 128\n target = tvm.target.Target(\"llvm\")\n task = auto_scheduler.SearchTask(func=matmul_auto_scheduler_test, args=(N, N, N), target=target)\n dag = task.compute_dag\n\n with tempfile.NamedTemporaryFile() as fp:\n log_file = fp.name\n\n search_policy = auto_scheduler.SketchPolicy(task)\n\n measure_ctx = auto_scheduler.LocalRPCMeasureContext()\n tuning_options = auto_scheduler.TuningOptions(\n num_measure_trials=2,\n runner=measure_ctx.runner,\n verbose=1,\n measure_callbacks=[auto_scheduler.RecordToFile(log_file)],\n )\n task.tune(tuning_options, search_policy=search_policy)\n inp, _ = auto_scheduler.load_best_record(log_file, task.workload_key, target)\n s, bufs = dag.apply_steps_from_state(\n inp.state, layout_rewrite=auto_scheduler.LayoutRewriteOption.INSERT_TRANSFORM_STAGE\n )\n\n s_ref, bufs_ref = dag.apply_steps_from_state(inp.state)\n np_args = [np.random.randn(*topi.get_const_tuple(x.shape)).astype(x.dtype) for x in bufs]\n\n func = tvm.build(s, bufs, target=target)\n func_ref = tvm.build(s_ref, bufs_ref, target=target)\n\n ctx = tvm.context(str(target))\n ctx_ref = tvm.cpu()\n\n args = [tvm.nd.array(x, ctx=ctx) for x in np_args]\n args_ref = [tvm.nd.array(x, ctx=ctx_ref) for x in np_args]\n ctx.sync()\n\n func(*args)\n func_ref(*args_ref)\n ctx.sync()\n\n tvm.testing.assert_allclose(args[0].asnumpy(), args_ref[0].asnumpy(), atol=1e-3, rtol=1e-3)\n tvm.testing.assert_allclose(args[1].asnumpy(), args_ref[1].asnumpy(), atol=1e-3, rtol=1e-3)\n tvm.testing.assert_allclose(args[2].asnumpy(), args_ref[2].asnumpy(), atol=1e-3, rtol=1e-3)\n del measure_ctx\n\n\nif __name__ == \"__main__\":\n test_apply_steps_with_layout_rewrite()\n test_apply_steps_with_layout_rewrite_corner_case()\n test_correctness_layout_rewrite_rewrite_for_preTransformed()\n test_correctness_layout_rewrite_insert_transform_stage()\n"
] |
[
[
"numpy.asarray",
"numpy.argmax",
"matplotlib.pyplot.show",
"numpy.squeeze",
"numpy.expand_dims",
"matplotlib.pyplot.imshow"
],
[
"numpy.random.uniform",
"numpy.zeros"
],
[
"numpy.array"
]
] |
Semih-Kurt/scvi-tools
|
[
"1bea2af8cc99e11d55a6925f09d978de5f6994fb",
"1bea2af8cc99e11d55a6925f09d978de5f6994fb",
"1bea2af8cc99e11d55a6925f09d978de5f6994fb"
] |
[
"tests/external/test_cellassign.py",
"scvi/model/_totalvi.py",
"tests/external/test_gimvi.py"
] |
[
"import numpy as np\nimport pandas as pd\n\nfrom scvi.data import synthetic_iid\nfrom scvi.external import CellAssign\n\n\ndef test_cellassign(save_path):\n adata = synthetic_iid(\n n_labels=5,\n )\n adata.obs[\"size_factor\"] = adata.X.sum(1)\n CellAssign.setup_anndata(\n adata,\n \"size_factor\",\n batch_key=\"batch\",\n )\n marker_df = pd.DataFrame(data=np.random.randint(2, size=(100, 5)))\n marker_df.index = marker_df.index.map(str)\n\n model = CellAssign(adata, marker_df)\n model.train(max_epochs=1)\n model.predict()\n",
"import logging\nimport warnings\nfrom collections.abc import Iterable as IterableClass\nfrom functools import partial\nfrom typing import Dict, Iterable, List, Optional, Sequence, Tuple, TypeVar, Union\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom anndata import AnnData\n\nfrom scvi import REGISTRY_KEYS\nfrom scvi._compat import Literal\nfrom scvi._utils import _doc_params\nfrom scvi.data._utils import _check_nonnegative_integers\nfrom scvi.data.anndata import AnnDataManager\nfrom scvi.data.anndata.fields import (\n CategoricalJointObsField,\n CategoricalObsField,\n LayerField,\n NumericalJointObsField,\n ProteinObsmField,\n)\nfrom scvi.dataloaders import DataSplitter\nfrom scvi.model._utils import (\n _get_batch_code_from_category,\n _init_library_size,\n cite_seq_raw_counts_properties,\n)\nfrom scvi.model.base._utils import _de_core\nfrom scvi.module import TOTALVAE\nfrom scvi.train import AdversarialTrainingPlan, TrainRunner\nfrom scvi.utils._docstrings import doc_differential_expression, setup_anndata_dsp\n\nfrom .base import ArchesMixin, BaseModelClass, RNASeqMixin, VAEMixin\n\nlogger = logging.getLogger(__name__)\nNumber = TypeVar(\"Number\", int, float)\n\n\nclass TOTALVI(RNASeqMixin, VAEMixin, ArchesMixin, BaseModelClass):\n \"\"\"\n total Variational Inference [GayosoSteier21]_.\n\n Parameters\n ----------\n adata\n AnnData object that has been registered via :meth:`~scvi.model.TOTALVI.setup_anndata`.\n n_latent\n Dimensionality of the latent space.\n gene_dispersion\n One of the following:\n\n * ``'gene'`` - genes_dispersion parameter of NB is constant per gene across cells\n * ``'gene-batch'`` - genes_dispersion can differ between different batches\n * ``'gene-label'`` - genes_dispersion can differ between different labels\n protein_dispersion\n One of the following:\n\n * ``'protein'`` - protein_dispersion parameter is constant per protein across cells\n * ``'protein-batch'`` - protein_dispersion can differ between different batches NOT TESTED\n * ``'protein-label'`` - protein_dispersion can differ between different labels NOT TESTED\n gene_likelihood\n One of:\n\n * ``'nb'`` - Negative binomial distribution\n * ``'zinb'`` - Zero-inflated negative binomial distribution\n latent_distribution\n One of:\n\n * ``'normal'`` - Normal distribution\n * ``'ln'`` - Logistic normal distribution (Normal(0, I) transformed by softmax)\n empirical_protein_background_prior\n Set the initialization of protein background prior empirically. This option fits a GMM for each of\n 100 cells per batch and averages the distributions. Note that even with this option set to `True`,\n this only initializes a parameter that is learned during inference. If `False`, randomly initializes.\n The default (`None`), sets this to `True` if greater than 10 proteins are used.\n override_missing_proteins\n If `True`, will not treat proteins with all 0 expression in a particular batch as missing.\n **model_kwargs\n Keyword args for :class:`~scvi.module.TOTALVAE`\n\n Examples\n --------\n >>> adata = anndata.read_h5ad(path_to_anndata)\n >>> scvi.model.TOTALVI.setup_anndata(adata, batch_key=\"batch\", protein_expression_obsm_key=\"protein_expression\")\n >>> vae = scvi.model.TOTALVI(adata)\n >>> vae.train()\n >>> adata.obsm[\"X_totalVI\"] = vae.get_latent_representation()\n\n Notes\n -----\n See further usage examples in the following tutorials:\n\n 1. :doc:`/tutorials/notebooks/totalVI`\n 2. :doc:`/tutorials/notebooks/cite_scrna_integration_w_totalVI`\n 3. :doc:`/tutorials/notebooks/scarches_scvi_tools`\n \"\"\"\n\n def __init__(\n self,\n adata: AnnData,\n n_latent: int = 20,\n gene_dispersion: Literal[\n \"gene\", \"gene-batch\", \"gene-label\", \"gene-cell\"\n ] = \"gene\",\n protein_dispersion: Literal[\n \"protein\", \"protein-batch\", \"protein-label\"\n ] = \"protein\",\n gene_likelihood: Literal[\"zinb\", \"nb\"] = \"nb\",\n latent_distribution: Literal[\"normal\", \"ln\"] = \"normal\",\n empirical_protein_background_prior: Optional[bool] = None,\n override_missing_proteins: bool = False,\n **model_kwargs,\n ):\n super(TOTALVI, self).__init__(adata)\n self.protein_state_registry = self.adata_manager.get_state_registry(\n REGISTRY_KEYS.PROTEIN_EXP_KEY\n )\n if (\n ProteinObsmField.PROTEIN_BATCH_MASK in self.protein_state_registry\n and not override_missing_proteins\n ):\n batch_mask = self.protein_state_registry.protein_batch_mask\n msg = (\n \"Some proteins have all 0 counts in some batches. \"\n + \"These proteins will be treated as missing measurements; however, \"\n + \"this can occur due to experimental design/biology. \"\n + \"Reinitialize the model with `override_missing_proteins=True`,\"\n + \"to override this behavior.\"\n )\n warnings.warn(msg, UserWarning)\n self._use_adversarial_classifier = True\n else:\n batch_mask = None\n self._use_adversarial_classifier = False\n\n emp_prior = (\n empirical_protein_background_prior\n if empirical_protein_background_prior is not None\n else (self.summary_stats.n_proteins > 10)\n )\n if emp_prior:\n prior_mean, prior_scale = self._get_totalvi_protein_priors(adata)\n else:\n prior_mean, prior_scale = None, None\n\n n_cats_per_cov = (\n self.adata_manager.get_state_registry(REGISTRY_KEYS.CAT_COVS_KEY)[\n CategoricalJointObsField.N_CATS_PER_KEY\n ]\n if REGISTRY_KEYS.CAT_COVS_KEY in self.adata_manager.data_registry\n else None\n )\n\n n_batch = self.summary_stats.n_batch\n library_log_means, library_log_vars = _init_library_size(\n self.adata_manager, n_batch\n )\n\n self.module = TOTALVAE(\n n_input_genes=self.summary_stats.n_vars,\n n_input_proteins=self.summary_stats.n_proteins,\n n_batch=n_batch,\n n_latent=n_latent,\n n_continuous_cov=self.summary_stats.get(\"n_extra_continuous_covs\", 0),\n n_cats_per_cov=n_cats_per_cov,\n gene_dispersion=gene_dispersion,\n protein_dispersion=protein_dispersion,\n gene_likelihood=gene_likelihood,\n latent_distribution=latent_distribution,\n protein_batch_mask=batch_mask,\n protein_background_prior_mean=prior_mean,\n protein_background_prior_scale=prior_scale,\n library_log_means=library_log_means,\n library_log_vars=library_log_vars,\n **model_kwargs,\n )\n self._model_summary_string = (\n \"TotalVI Model with the following params: \\nn_latent: {}, \"\n \"gene_dispersion: {}, protein_dispersion: {}, gene_likelihood: {}, latent_distribution: {}\"\n ).format(\n n_latent,\n gene_dispersion,\n protein_dispersion,\n gene_likelihood,\n latent_distribution,\n )\n self.init_params_ = self._get_init_params(locals())\n\n def train(\n self,\n max_epochs: Optional[int] = 400,\n lr: float = 4e-3,\n use_gpu: Optional[Union[str, int, bool]] = None,\n train_size: float = 0.9,\n validation_size: Optional[float] = None,\n batch_size: int = 256,\n early_stopping: bool = True,\n check_val_every_n_epoch: Optional[int] = None,\n reduce_lr_on_plateau: bool = True,\n n_steps_kl_warmup: Union[int, None] = None,\n n_epochs_kl_warmup: Union[int, None] = None,\n adversarial_classifier: Optional[bool] = None,\n plan_kwargs: Optional[dict] = None,\n **kwargs,\n ):\n \"\"\"\n Trains the model using amortized variational inference.\n\n Parameters\n ----------\n max_epochs\n Number of passes through the dataset.\n lr\n Learning rate for optimization.\n use_gpu\n Use default GPU if available (if None or True), or index of GPU to use (if int),\n or name of GPU (if str, e.g., `'cuda:0'`), or use CPU (if False).\n train_size\n Size of training set in the range [0.0, 1.0].\n validation_size\n Size of the test set. If `None`, defaults to 1 - `train_size`. If\n `train_size + validation_size < 1`, the remaining cells belong to a test set.\n batch_size\n Minibatch size to use during training.\n early_stopping\n Whether to perform early stopping with respect to the validation set.\n check_val_every_n_epoch\n Check val every n train epochs. By default, val is not checked, unless `early_stopping` is `True`\n or `reduce_lr_on_plateau` is `True`. If either of the latter conditions are met, val is checked\n every epoch.\n reduce_lr_on_plateau\n Reduce learning rate on plateau of validation metric (default is ELBO).\n n_steps_kl_warmup\n Number of training steps (minibatches) to scale weight on KL divergences from 0 to 1.\n Only activated when `n_epochs_kl_warmup` is set to None. If `None`, defaults\n to `floor(0.75 * adata.n_obs)`.\n n_epochs_kl_warmup\n Number of epochs to scale weight on KL divergences from 0 to 1.\n Overrides `n_steps_kl_warmup` when both are not `None`.\n adversarial_classifier\n Whether to use adversarial classifier in the latent space. This helps mixing when\n there are missing proteins in any of the batches. Defaults to `True` is missing proteins\n are detected.\n plan_kwargs\n Keyword args for :class:`~scvi.train.AdversarialTrainingPlan`. Keyword arguments passed to\n `train()` will overwrite values present in `plan_kwargs`, when appropriate.\n **kwargs\n Other keyword args for :class:`~scvi.train.Trainer`.\n \"\"\"\n if adversarial_classifier is None:\n adversarial_classifier = self._use_adversarial_classifier\n n_steps_kl_warmup = (\n n_steps_kl_warmup\n if n_steps_kl_warmup is not None\n else int(0.75 * self.adata.n_obs)\n )\n if reduce_lr_on_plateau:\n check_val_every_n_epoch = 1\n\n update_dict = {\n \"lr\": lr,\n \"adversarial_classifier\": adversarial_classifier,\n \"reduce_lr_on_plateau\": reduce_lr_on_plateau,\n \"n_epochs_kl_warmup\": n_epochs_kl_warmup,\n \"n_steps_kl_warmup\": n_steps_kl_warmup,\n \"check_val_every_n_epoch\": check_val_every_n_epoch,\n }\n if plan_kwargs is not None:\n plan_kwargs.update(update_dict)\n else:\n plan_kwargs = update_dict\n\n if max_epochs is None:\n n_cells = self.adata.n_obs\n max_epochs = np.min([round((20000 / n_cells) * 400), 400])\n\n plan_kwargs = plan_kwargs if isinstance(plan_kwargs, dict) else dict()\n\n data_splitter = DataSplitter(\n self.adata_manager,\n train_size=train_size,\n validation_size=validation_size,\n batch_size=batch_size,\n use_gpu=use_gpu,\n )\n training_plan = AdversarialTrainingPlan(self.module, **plan_kwargs)\n runner = TrainRunner(\n self,\n training_plan=training_plan,\n data_splitter=data_splitter,\n max_epochs=max_epochs,\n use_gpu=use_gpu,\n early_stopping=early_stopping,\n **kwargs,\n )\n return runner()\n\n @torch.no_grad()\n def get_latent_library_size(\n self,\n adata: Optional[AnnData] = None,\n indices: Optional[Sequence[int]] = None,\n give_mean: bool = True,\n batch_size: Optional[int] = None,\n ) -> np.ndarray:\n r\"\"\"\n Returns the latent library size for each cell.\n\n This is denoted as :math:`\\ell_n` in the totalVI paper.\n\n Parameters\n ----------\n adata\n AnnData object with equivalent structure to initial AnnData. If `None`, defaults to the\n AnnData object used to initialize the model.\n indices\n Indices of cells in adata to use. If `None`, all cells are used.\n give_mean\n Return the mean or a sample from the posterior distribution.\n batch_size\n Minibatch size for data loading into model. Defaults to `scvi.settings.batch_size`.\n \"\"\"\n self._check_if_trained(warn=False)\n\n adata = self._validate_anndata(adata)\n post = self._make_data_loader(\n adata=adata, indices=indices, batch_size=batch_size\n )\n libraries = []\n for tensors in post:\n inference_inputs = self.module._get_inference_input(tensors)\n outputs = self.module.inference(**inference_inputs)\n if give_mean:\n ql_m = outputs[\"ql_m\"]\n ql_v = outputs[\"ql_v\"]\n library = torch.exp(ql_m + 0.5 * ql_v)\n else:\n library = outputs[\"library_gene\"]\n libraries += [library.cpu()]\n return torch.cat(libraries).numpy()\n\n @torch.no_grad()\n def get_normalized_expression(\n self,\n adata=None,\n indices=None,\n n_samples_overall: Optional[int] = None,\n transform_batch: Optional[Sequence[Union[Number, str]]] = None,\n gene_list: Optional[Sequence[str]] = None,\n protein_list: Optional[Sequence[str]] = None,\n library_size: Optional[Union[float, Literal[\"latent\"]]] = 1,\n n_samples: int = 1,\n sample_protein_mixing: bool = False,\n scale_protein: bool = False,\n include_protein_background: bool = False,\n batch_size: Optional[int] = None,\n return_mean: bool = True,\n return_numpy: Optional[bool] = None,\n ) -> Tuple[Union[np.ndarray, pd.DataFrame], Union[np.ndarray, pd.DataFrame]]:\n r\"\"\"\n Returns the normalized gene expression and protein expression.\n\n This is denoted as :math:`\\rho_n` in the totalVI paper for genes, and TODO\n for proteins, :math:`(1-\\pi_{nt})\\alpha_{nt}\\beta_{nt}`.\n\n Parameters\n ----------\n adata\n AnnData object with equivalent structure to initial AnnData. If `None`, defaults to the\n AnnData object used to initialize the model.\n indices\n Indices of cells in adata to use. If `None`, all cells are used.\n n_samples_overall\n Number of samples to use in total\n transform_batch\n Batch to condition on.\n If transform_batch is:\n\n - None, then real observed batch is used\n - int, then batch transform_batch is used\n - List[int], then average over batches in list\n gene_list\n Return frequencies of expression for a subset of genes.\n This can save memory when working with large datasets and few genes are\n of interest.\n protein_list\n Return protein expression for a subset of genes.\n This can save memory when working with large datasets and few genes are\n of interest.\n library_size\n Scale the expression frequencies to a common library size.\n This allows gene expression levels to be interpreted on a common scale of relevant\n magnitude.\n n_samples\n Get sample scale from multiple samples.\n sample_protein_mixing\n Sample mixing bernoulli, setting background to zero\n scale_protein\n Make protein expression sum to 1\n include_protein_background\n Include background component for protein expression\n batch_size\n Minibatch size for data loading into model. Defaults to `scvi.settings.batch_size`.\n return_mean\n Whether to return the mean of the samples.\n return_numpy\n Return a `np.ndarray` instead of a `pd.DataFrame`. Includes gene\n names as columns. If either n_samples=1 or return_mean=True, defaults to False.\n Otherwise, it defaults to True.\n\n Returns\n -------\n - **gene_normalized_expression** - normalized expression for RNA\n - **protein_normalized_expression** - normalized expression for proteins\n\n If ``n_samples`` > 1 and ``return_mean`` is False, then the shape is ``(samples, cells, genes)``.\n Otherwise, shape is ``(cells, genes)``. Return type is ``pd.DataFrame`` unless ``return_numpy`` is True.\n \"\"\"\n adata = self._validate_anndata(adata)\n adata_manager = self.get_anndata_manager(adata)\n if indices is None:\n indices = np.arange(adata.n_obs)\n if n_samples_overall is not None:\n indices = np.random.choice(indices, n_samples_overall)\n post = self._make_data_loader(\n adata=adata, indices=indices, batch_size=batch_size\n )\n\n if gene_list is None:\n gene_mask = slice(None)\n else:\n all_genes = adata.var_names\n gene_mask = [True if gene in gene_list else False for gene in all_genes]\n if protein_list is None:\n protein_mask = slice(None)\n else:\n all_proteins = self.protein_state_registry.column_names\n protein_mask = [True if p in protein_list else False for p in all_proteins]\n if indices is None:\n indices = np.arange(adata.n_obs)\n\n if n_samples > 1 and return_mean is False:\n if return_numpy is False:\n warnings.warn(\n \"return_numpy must be True if n_samples > 1 and return_mean is False, returning np.ndarray\"\n )\n return_numpy = True\n\n if not isinstance(transform_batch, IterableClass):\n transform_batch = [transform_batch]\n\n transform_batch = _get_batch_code_from_category(adata_manager, transform_batch)\n\n scale_list_gene = []\n scale_list_pro = []\n\n for tensors in post:\n x = tensors[REGISTRY_KEYS.X_KEY]\n y = tensors[REGISTRY_KEYS.PROTEIN_EXP_KEY]\n px_scale = torch.zeros_like(x)\n py_scale = torch.zeros_like(y)\n if n_samples > 1:\n px_scale = torch.stack(n_samples * [px_scale])\n py_scale = torch.stack(n_samples * [py_scale])\n for b in transform_batch:\n generative_kwargs = dict(transform_batch=b)\n inference_kwargs = dict(n_samples=n_samples)\n _, generative_outputs = self.module.forward(\n tensors=tensors,\n inference_kwargs=inference_kwargs,\n generative_kwargs=generative_kwargs,\n compute_loss=False,\n )\n if library_size == \"latent\":\n px_scale += generative_outputs[\"px_\"][\"rate\"].cpu()\n else:\n px_scale += generative_outputs[\"px_\"][\"scale\"].cpu()\n px_scale = px_scale[..., gene_mask]\n\n py_ = generative_outputs[\"py_\"]\n # probability of background\n protein_mixing = 1 / (1 + torch.exp(-py_[\"mixing\"].cpu()))\n if sample_protein_mixing is True:\n protein_mixing = torch.distributions.Bernoulli(\n protein_mixing\n ).sample()\n protein_val = py_[\"rate_fore\"].cpu() * (1 - protein_mixing)\n if include_protein_background is True:\n protein_val += py_[\"rate_back\"].cpu() * protein_mixing\n\n if scale_protein is True:\n protein_val = torch.nn.functional.normalize(\n protein_val, p=1, dim=-1\n )\n protein_val = protein_val[..., protein_mask]\n py_scale += protein_val\n px_scale /= len(transform_batch)\n py_scale /= len(transform_batch)\n scale_list_gene.append(px_scale)\n scale_list_pro.append(py_scale)\n\n if n_samples > 1:\n # concatenate along batch dimension -> result shape = (samples, cells, features)\n scale_list_gene = torch.cat(scale_list_gene, dim=1)\n scale_list_pro = torch.cat(scale_list_pro, dim=1)\n # (cells, features, samples)\n scale_list_gene = scale_list_gene.permute(1, 2, 0)\n scale_list_pro = scale_list_pro.permute(1, 2, 0)\n else:\n scale_list_gene = torch.cat(scale_list_gene, dim=0)\n scale_list_pro = torch.cat(scale_list_pro, dim=0)\n\n if return_mean is True and n_samples > 1:\n scale_list_gene = torch.mean(scale_list_gene, dim=-1)\n scale_list_pro = torch.mean(scale_list_pro, dim=-1)\n\n scale_list_gene = scale_list_gene.cpu().numpy()\n scale_list_pro = scale_list_pro.cpu().numpy()\n if return_numpy is None or return_numpy is False:\n gene_df = pd.DataFrame(\n scale_list_gene,\n columns=adata.var_names[gene_mask],\n index=adata.obs_names[indices],\n )\n protein_names = self.protein_state_registry.column_names\n pro_df = pd.DataFrame(\n scale_list_pro,\n columns=protein_names[protein_mask],\n index=adata.obs_names[indices],\n )\n\n return gene_df, pro_df\n else:\n return scale_list_gene, scale_list_pro\n\n @torch.no_grad()\n def get_protein_foreground_probability(\n self,\n adata: Optional[AnnData] = None,\n indices: Optional[Sequence[int]] = None,\n transform_batch: Optional[Sequence[Union[Number, str]]] = None,\n protein_list: Optional[Sequence[str]] = None,\n n_samples: int = 1,\n batch_size: Optional[int] = None,\n return_mean: bool = True,\n return_numpy: Optional[bool] = None,\n ):\n r\"\"\"\n Returns the foreground probability for proteins.\n\n This is denoted as :math:`(1 - \\pi_{nt})` in the totalVI paper.\n\n Parameters\n ----------\n adata\n AnnData object with equivalent structure to initial AnnData. If `None`, defaults to the\n AnnData object used to initialize the model.\n indices\n Indices of cells in adata to use. If `None`, all cells are used.\n transform_batch\n Batch to condition on.\n If transform_batch is:\n\n - None, then real observed batch is used\n - int, then batch transform_batch is used\n - List[int], then average over batches in list\n protein_list\n Return protein expression for a subset of genes.\n This can save memory when working with large datasets and few genes are\n of interest.\n n_samples\n Number of posterior samples to use for estimation.\n batch_size\n Minibatch size for data loading into model. Defaults to `scvi.settings.batch_size`.\n return_mean\n Whether to return the mean of the samples.\n return_numpy\n Return a :class:`~numpy.ndarray` instead of a :class:`~pandas.DataFrame`. DataFrame includes\n gene names as columns. If either `n_samples=1` or `return_mean=True`, defaults to `False`.\n Otherwise, it defaults to `True`.\n\n Returns\n -------\n - **foreground_probability** - probability foreground for each protein\n\n If `n_samples` > 1 and `return_mean` is False, then the shape is `(samples, cells, genes)`.\n Otherwise, shape is `(cells, genes)`. In this case, return type is :class:`~pandas.DataFrame` unless `return_numpy` is True.\n \"\"\"\n adata = self._validate_anndata(adata)\n post = self._make_data_loader(\n adata=adata, indices=indices, batch_size=batch_size\n )\n\n if protein_list is None:\n protein_mask = slice(None)\n else:\n all_proteins = self.protein_state_registry.column_names\n protein_mask = [True if p in protein_list else False for p in all_proteins]\n\n if n_samples > 1 and return_mean is False:\n if return_numpy is False:\n warnings.warn(\n \"return_numpy must be True if n_samples > 1 and return_mean is False, returning np.ndarray\"\n )\n return_numpy = True\n if indices is None:\n indices = np.arange(adata.n_obs)\n\n py_mixings = []\n if not isinstance(transform_batch, IterableClass):\n transform_batch = [transform_batch]\n\n transform_batch = _get_batch_code_from_category(\n self.adata_manager, transform_batch\n )\n for tensors in post:\n y = tensors[REGISTRY_KEYS.PROTEIN_EXP_KEY]\n py_mixing = torch.zeros_like(y[..., protein_mask])\n if n_samples > 1:\n py_mixing = torch.stack(n_samples * [py_mixing])\n for b in transform_batch:\n generative_kwargs = dict(transform_batch=b)\n inference_kwargs = dict(n_samples=n_samples)\n _, generative_outputs = self.module.forward(\n tensors=tensors,\n inference_kwargs=inference_kwargs,\n generative_kwargs=generative_kwargs,\n compute_loss=False,\n )\n py_mixing += torch.sigmoid(generative_outputs[\"py_\"][\"mixing\"])[\n ..., protein_mask\n ].cpu()\n py_mixing /= len(transform_batch)\n py_mixings += [py_mixing]\n if n_samples > 1:\n # concatenate along batch dimension -> result shape = (samples, cells, features)\n py_mixings = torch.cat(py_mixings, dim=1)\n # (cells, features, samples)\n py_mixings = py_mixings.permute(1, 2, 0)\n else:\n py_mixings = torch.cat(py_mixings, dim=0)\n\n if return_mean is True and n_samples > 1:\n py_mixings = torch.mean(py_mixings, dim=-1)\n\n py_mixings = py_mixings.cpu().numpy()\n\n if return_numpy is True:\n return 1 - py_mixings\n else:\n pro_names = self.protein_state_registry.column_names\n foreground_prob = pd.DataFrame(\n 1 - py_mixings,\n columns=pro_names[protein_mask],\n index=adata.obs_names[indices],\n )\n return foreground_prob\n\n def _expression_for_de(\n self,\n adata=None,\n indices=None,\n n_samples_overall=None,\n transform_batch: Optional[Sequence[Union[Number, str]]] = None,\n scale_protein=False,\n batch_size: Optional[int] = None,\n sample_protein_mixing=False,\n include_protein_background=False,\n protein_prior_count=0.5,\n ):\n rna, protein = self.get_normalized_expression(\n adata=adata,\n indices=indices,\n n_samples_overall=n_samples_overall,\n transform_batch=transform_batch,\n return_numpy=True,\n n_samples=1,\n batch_size=batch_size,\n scale_protein=scale_protein,\n sample_protein_mixing=sample_protein_mixing,\n include_protein_background=include_protein_background,\n )\n protein += protein_prior_count\n\n joint = np.concatenate([rna, protein], axis=1)\n return joint\n\n @_doc_params(\n doc_differential_expression=doc_differential_expression,\n )\n def differential_expression(\n self,\n adata: Optional[AnnData] = None,\n groupby: Optional[str] = None,\n group1: Optional[Iterable[str]] = None,\n group2: Optional[str] = None,\n idx1: Optional[Union[Sequence[int], Sequence[bool], str]] = None,\n idx2: Optional[Union[Sequence[int], Sequence[bool], str]] = None,\n mode: Literal[\"vanilla\", \"change\"] = \"change\",\n delta: float = 0.25,\n batch_size: Optional[int] = None,\n all_stats: bool = True,\n batch_correction: bool = False,\n batchid1: Optional[Iterable[str]] = None,\n batchid2: Optional[Iterable[str]] = None,\n fdr_target: float = 0.05,\n silent: bool = False,\n protein_prior_count: float = 0.1,\n scale_protein: bool = False,\n sample_protein_mixing: bool = False,\n include_protein_background: bool = False,\n **kwargs,\n ) -> pd.DataFrame:\n r\"\"\"\n A unified method for differential expression analysis.\n\n Implements `\"vanilla\"` DE [Lopez18]_ and `\"change\"` mode DE [Boyeau19]_.\n\n Parameters\n ----------\n {doc_differential_expression}\n protein_prior_count\n Prior count added to protein expression before LFC computation\n scale_protein\n Force protein values to sum to one in every single cell (post-hoc normalization)\n sample_protein_mixing\n Sample the protein mixture component, i.e., use the parameter to sample a Bernoulli\n that determines if expression is from foreground/background.\n include_protein_background\n Include the protein background component as part of the protein expression\n **kwargs\n Keyword args for :meth:`scvi.model.base.DifferentialComputation.get_bayes_factors`\n\n Returns\n -------\n Differential expression DataFrame.\n \"\"\"\n adata = self._validate_anndata(adata)\n model_fn = partial(\n self._expression_for_de,\n scale_protein=scale_protein,\n sample_protein_mixing=sample_protein_mixing,\n include_protein_background=include_protein_background,\n protein_prior_count=protein_prior_count,\n batch_size=batch_size,\n )\n col_names = np.concatenate(\n [\n np.asarray(adata.var_names),\n self.protein_state_registry.column_names,\n ]\n )\n result = _de_core(\n self.get_anndata_manager(adata, required=True),\n model_fn,\n groupby,\n group1,\n group2,\n idx1,\n idx2,\n all_stats,\n cite_seq_raw_counts_properties,\n col_names,\n mode,\n batchid1,\n batchid2,\n delta,\n batch_correction,\n fdr_target,\n silent,\n **kwargs,\n )\n\n return result\n\n @torch.no_grad()\n def posterior_predictive_sample(\n self,\n adata: Optional[AnnData] = None,\n indices: Optional[Sequence[int]] = None,\n n_samples: int = 1,\n batch_size: Optional[int] = None,\n gene_list: Optional[Sequence[str]] = None,\n protein_list: Optional[Sequence[str]] = None,\n ) -> np.ndarray:\n r\"\"\"\n Generate observation samples from the posterior predictive distribution.\n\n The posterior predictive distribution is written as :math:`p(\\hat{x}, \\hat{y} \\mid x, y)`.\n\n Parameters\n ----------\n adata\n AnnData object with equivalent structure to initial AnnData. If `None`, defaults to the\n AnnData object used to initialize the model.\n indices\n Indices of cells in adata to use. If `None`, all cells are used.\n n_samples\n Number of required samples for each cell\n batch_size\n Minibatch size for data loading into model. Defaults to `scvi.settings.batch_size`.\n gene_list\n Names of genes of interest\n protein_list\n Names of proteins of interest\n\n Returns\n -------\n x_new : :class:`~numpy.ndarray`\n tensor with shape (n_cells, n_genes, n_samples)\n \"\"\"\n if self.module.gene_likelihood not in [\"nb\"]:\n raise ValueError(\"Invalid gene_likelihood\")\n\n adata = self._validate_anndata(adata)\n if gene_list is None:\n gene_mask = slice(None)\n else:\n all_genes = adata.var_names\n gene_mask = [True if gene in gene_list else False for gene in all_genes]\n if protein_list is None:\n protein_mask = slice(None)\n else:\n all_proteins = self.protein_state_registry.column_names\n protein_mask = [True if p in protein_list else False for p in all_proteins]\n\n scdl = self._make_data_loader(\n adata=adata, indices=indices, batch_size=batch_size\n )\n\n scdl_list = []\n for tensors in scdl:\n rna_sample, protein_sample = self.module.sample(\n tensors, n_samples=n_samples\n )\n rna_sample = rna_sample[..., gene_mask]\n protein_sample = protein_sample[..., protein_mask]\n data = torch.cat([rna_sample, protein_sample], dim=-1).numpy()\n\n scdl_list += [data]\n if n_samples > 1:\n scdl_list[-1] = np.transpose(scdl_list[-1], (1, 2, 0))\n scdl_list = np.concatenate(scdl_list, axis=0)\n\n return scdl_list\n\n @torch.no_grad()\n def _get_denoised_samples(\n self,\n adata=None,\n indices=None,\n n_samples: int = 25,\n batch_size: int = 64,\n rna_size_factor: int = 1000,\n transform_batch: Optional[int] = None,\n ) -> np.ndarray:\n \"\"\"\n Return samples from an adjusted posterior predictive.\n\n Parameters\n ----------\n adata\n AnnData object with equivalent structure to initial AnnData. If `None`, defaults to the\n AnnData object used to initialize the model.\n indices\n indices of `adata` to use\n n_samples\n How may samples per cell\n batch_size\n Minibatch size for data loading into model. Defaults to `scvi.settings.batch_size`.\n rna_size_factor\n size factor for RNA prior to sampling gamma distribution\n transform_batch\n int of which batch to condition on for all cells\n \"\"\"\n adata = self._validate_anndata(adata)\n scdl = self._make_data_loader(\n adata=adata, indices=indices, batch_size=batch_size\n )\n\n scdl_list = []\n for tensors in scdl:\n x = tensors[REGISTRY_KEYS.X_KEY]\n y = tensors[REGISTRY_KEYS.PROTEIN_EXP_KEY]\n\n generative_kwargs = dict(transform_batch=transform_batch)\n inference_kwargs = dict(n_samples=n_samples)\n with torch.no_grad():\n inference_outputs, generative_outputs, = self.module.forward(\n tensors,\n inference_kwargs=inference_kwargs,\n generative_kwargs=generative_kwargs,\n compute_loss=False,\n )\n px_ = generative_outputs[\"px_\"]\n py_ = generative_outputs[\"py_\"]\n device = px_[\"r\"].device\n\n pi = 1 / (1 + torch.exp(-py_[\"mixing\"]))\n mixing_sample = torch.distributions.Bernoulli(pi).sample()\n protein_rate = py_[\"rate_fore\"]\n rate = torch.cat((rna_size_factor * px_[\"scale\"], protein_rate), dim=-1)\n if len(px_[\"r\"].size()) == 2:\n px_dispersion = px_[\"r\"]\n else:\n px_dispersion = torch.ones_like(x).to(device) * px_[\"r\"]\n if len(py_[\"r\"].size()) == 2:\n py_dispersion = py_[\"r\"]\n else:\n py_dispersion = torch.ones_like(y).to(device) * py_[\"r\"]\n\n dispersion = torch.cat((px_dispersion, py_dispersion), dim=-1)\n\n # This gamma is really l*w using scVI manuscript notation\n p = rate / (rate + dispersion)\n r = dispersion\n l_train = torch.distributions.Gamma(r, (1 - p) / p).sample()\n data = l_train.cpu().numpy()\n # make background 0\n data[:, :, self.adata.shape[1] :] = (\n data[:, :, self.adata.shape[1] :] * (1 - mixing_sample).cpu().numpy()\n )\n scdl_list += [data]\n\n scdl_list[-1] = np.transpose(scdl_list[-1], (1, 2, 0))\n\n return np.concatenate(scdl_list, axis=0)\n\n @torch.no_grad()\n def get_feature_correlation_matrix(\n self,\n adata=None,\n indices=None,\n n_samples: int = 10,\n batch_size: int = 64,\n rna_size_factor: int = 1000,\n transform_batch: Optional[Sequence[Union[Number, str]]] = None,\n correlation_type: Literal[\"spearman\", \"pearson\"] = \"spearman\",\n log_transform: bool = False,\n ) -> pd.DataFrame:\n \"\"\"\n Generate gene-gene correlation matrix using scvi uncertainty and expression.\n\n Parameters\n ----------\n adata\n AnnData object with equivalent structure to initial AnnData. If `None`, defaults to the\n AnnData object used to initialize the model.\n indices\n Indices of cells in adata to use. If `None`, all cells are used.\n n_samples\n Number of posterior samples to use for estimation.\n batch_size\n Minibatch size for data loading into model. Defaults to `scvi.settings.batch_size`.\n rna_size_factor\n size factor for RNA prior to sampling gamma distribution\n transform_batch\n Batches to condition on.\n If transform_batch is:\n\n - None, then real observed batch is used\n - int, then batch transform_batch is used\n - list of int, then values are averaged over provided batches.\n correlation_type\n One of \"pearson\", \"spearman\".\n log_transform\n Whether to log transform denoised values prior to correlation calculation.\n\n Returns\n -------\n Gene-protein-gene-protein correlation matrix\n \"\"\"\n from scipy.stats import spearmanr\n\n adata = self._validate_anndata(adata)\n\n if not isinstance(transform_batch, IterableClass):\n transform_batch = [transform_batch]\n\n transform_batch = _get_batch_code_from_category(\n self.get_anndata_manager(adata, required=True), transform_batch\n )\n\n corr_mats = []\n for b in transform_batch:\n denoised_data = self._get_denoised_samples(\n n_samples=n_samples,\n batch_size=batch_size,\n rna_size_factor=rna_size_factor,\n transform_batch=b,\n )\n flattened = np.zeros(\n (denoised_data.shape[0] * n_samples, denoised_data.shape[1])\n )\n for i in range(n_samples):\n flattened[\n denoised_data.shape[0] * (i) : denoised_data.shape[0] * (i + 1)\n ] = denoised_data[:, :, i]\n if log_transform is True:\n flattened[:, : self.n_genes] = np.log(\n flattened[:, : self.n_genes] + 1e-8\n )\n flattened[:, self.n_genes :] = np.log1p(flattened[:, self.n_genes :])\n if correlation_type == \"pearson\":\n corr_matrix = np.corrcoef(flattened, rowvar=False)\n else:\n corr_matrix, _ = spearmanr(flattened, axis=0)\n corr_mats.append(corr_matrix)\n\n corr_matrix = np.mean(np.stack(corr_mats), axis=0)\n var_names = adata.var_names\n names = np.concatenate(\n [\n np.asarray(var_names),\n self.protein_state_registry.column_names,\n ]\n )\n return pd.DataFrame(corr_matrix, index=names, columns=names)\n\n @torch.no_grad()\n def get_likelihood_parameters(\n self,\n adata: Optional[AnnData] = None,\n indices: Optional[Sequence[int]] = None,\n n_samples: Optional[int] = 1,\n give_mean: Optional[bool] = False,\n batch_size: Optional[int] = None,\n ) -> Dict[str, np.ndarray]:\n r\"\"\"\n Estimates for the parameters of the likelihood :math:`p(x, y \\mid z)`.\n\n Parameters\n ----------\n adata\n AnnData object with equivalent structure to initial AnnData. If `None`, defaults to the\n AnnData object used to initialize the model.\n indices\n Indices of cells in adata to use. If `None`, all cells are used.\n n_samples\n Number of posterior samples to use for estimation.\n give_mean\n Return expected value of parameters or a samples\n batch_size\n Minibatch size for data loading into model. Defaults to `scvi.settings.batch_size`.\n \"\"\"\n raise NotImplementedError\n\n def _validate_anndata(\n self, adata: Optional[AnnData] = None, copy_if_view: bool = True\n ):\n adata = super()._validate_anndata(adata=adata, copy_if_view=copy_if_view)\n error_msg = \"Number of {} in anndata different from when setup_anndata was run. Please rerun setup_anndata.\"\n if REGISTRY_KEYS.PROTEIN_EXP_KEY in self.adata_manager.data_registry.keys():\n pro_exp = self.get_from_registry(adata, REGISTRY_KEYS.PROTEIN_EXP_KEY)\n if self.summary_stats.n_proteins != pro_exp.shape[1]:\n raise ValueError(error_msg.format(\"proteins\"))\n is_nonneg_int = _check_nonnegative_integers(pro_exp)\n if not is_nonneg_int:\n warnings.warn(\n \"Make sure the registered protein expression in anndata contains unnormalized count data.\"\n )\n else:\n raise ValueError(\"No protein data found, please setup or transfer anndata\")\n\n return adata\n\n def _get_totalvi_protein_priors(self, adata, n_cells=100):\n \"\"\"Compute an empirical prior for protein background.\"\"\"\n import warnings\n\n from sklearn.exceptions import ConvergenceWarning\n from sklearn.mixture import GaussianMixture\n\n warnings.filterwarnings(\"error\")\n logger.info(\"Computing empirical prior initialization for protein background.\")\n\n adata = self._validate_anndata(adata)\n adata_manager = self.get_anndata_manager(adata)\n pro_exp = adata_manager.get_from_registry(REGISTRY_KEYS.PROTEIN_EXP_KEY)\n pro_exp = pro_exp.to_numpy() if isinstance(pro_exp, pd.DataFrame) else pro_exp\n batch_mask = adata_manager.get_state_registry(\n REGISTRY_KEYS.PROTEIN_EXP_KEY\n ).get(ProteinObsmField.PROTEIN_BATCH_MASK)\n batch = adata_manager.get_from_registry(REGISTRY_KEYS.BATCH_KEY).ravel()\n cats = adata_manager.get_state_registry(REGISTRY_KEYS.BATCH_KEY)[\n CategoricalObsField.CATEGORICAL_MAPPING_KEY\n ]\n codes = np.arange(len(cats))\n\n batch_avg_mus, batch_avg_scales = [], []\n for b in np.unique(codes):\n # can happen during online updates\n # the values of these batches will not be used\n num_in_batch = np.sum(batch == b)\n if num_in_batch == 0:\n batch_avg_mus.append(0)\n batch_avg_scales.append(1)\n continue\n batch_pro_exp = pro_exp[batch == b]\n\n # non missing\n if batch_mask is not None:\n batch_pro_exp = batch_pro_exp[:, batch_mask[b]]\n if batch_pro_exp.shape[1] < 5:\n logger.debug(\n f\"Batch {b} has too few proteins to set prior, setting randomly.\"\n )\n batch_avg_mus.append(0.0)\n batch_avg_scales.append(0.05)\n continue\n\n # a batch is missing because it's in the reference but not query data\n # for scarches case, these values will be replaced by original state dict\n if batch_pro_exp.shape[0] == 0:\n batch_avg_mus.append(0.0)\n batch_avg_scales.append(0.05)\n continue\n\n cells = np.random.choice(np.arange(batch_pro_exp.shape[0]), size=n_cells)\n batch_pro_exp = batch_pro_exp[cells]\n gmm = GaussianMixture(n_components=2)\n mus, scales = [], []\n # fit per cell GMM\n for c in batch_pro_exp:\n try:\n gmm.fit(np.log1p(c.reshape(-1, 1)))\n # when cell is all 0\n except ConvergenceWarning:\n mus.append(0)\n scales.append(0.05)\n continue\n\n means = gmm.means_.ravel()\n sorted_fg_bg = np.argsort(means)\n mu = means[sorted_fg_bg].ravel()[0]\n covariances = gmm.covariances_[sorted_fg_bg].ravel()[0]\n scale = np.sqrt(covariances)\n mus.append(mu)\n scales.append(scale)\n\n # average distribution over cells\n batch_avg_mu = np.mean(mus)\n batch_avg_scale = np.sqrt(np.sum(np.square(scales)) / (n_cells**2))\n\n batch_avg_mus.append(batch_avg_mu)\n batch_avg_scales.append(batch_avg_scale)\n\n # repeat prior for each protein\n batch_avg_mus = np.array(batch_avg_mus, dtype=np.float32).reshape(1, -1)\n batch_avg_scales = np.array(batch_avg_scales, dtype=np.float32).reshape(1, -1)\n batch_avg_mus = np.tile(batch_avg_mus, (pro_exp.shape[1], 1))\n batch_avg_scales = np.tile(batch_avg_scales, (pro_exp.shape[1], 1))\n\n warnings.resetwarnings()\n\n return batch_avg_mus, batch_avg_scales\n\n @torch.no_grad()\n def get_protein_background_mean(self, adata, indices, batch_size):\n adata = self._validate_anndata(adata)\n scdl = self._make_data_loader(\n adata=adata, indices=indices, batch_size=batch_size\n )\n background_mean = []\n for tensors in scdl:\n _, inference_outputs, _ = self.module.forward(tensors)\n b_mean = inference_outputs[\"py_\"][\"rate_back\"]\n background_mean += [b_mean.cpu().numpy()]\n return np.concatenate(background_mean)\n\n @classmethod\n @setup_anndata_dsp.dedent\n def setup_anndata(\n cls,\n adata: AnnData,\n protein_expression_obsm_key: str,\n protein_names_uns_key: Optional[str] = None,\n batch_key: Optional[str] = None,\n layer: Optional[str] = None,\n categorical_covariate_keys: Optional[List[str]] = None,\n continuous_covariate_keys: Optional[List[str]] = None,\n **kwargs,\n ) -> Optional[AnnData]:\n \"\"\"\n %(summary)s.\n\n Parameters\n ----------\n %(param_adata)s\n protein_expression_obsm_key\n key in `adata.obsm` for protein expression data.\n protein_names_uns_key\n key in `adata.uns` for protein names. If None, will use the column names of `adata.obsm[protein_expression_obsm_key]`\n if it is a DataFrame, else will assign sequential names to proteins.\n %(param_batch_key)s\n %(param_layer)s\n %(param_cat_cov_keys)s\n %(param_cont_cov_keys)s\n %(param_copy)s\n\n Returns\n -------\n %(returns)s\n \"\"\"\n setup_method_args = cls._get_setup_method_args(**locals())\n batch_field = CategoricalObsField(REGISTRY_KEYS.BATCH_KEY, batch_key)\n anndata_fields = [\n LayerField(REGISTRY_KEYS.X_KEY, layer, is_count_data=True),\n CategoricalObsField(\n REGISTRY_KEYS.LABELS_KEY, None\n ), # Default labels field for compatibility with TOTALVAE\n batch_field,\n CategoricalJointObsField(\n REGISTRY_KEYS.CAT_COVS_KEY, categorical_covariate_keys\n ),\n NumericalJointObsField(\n REGISTRY_KEYS.CONT_COVS_KEY, continuous_covariate_keys\n ),\n ProteinObsmField(\n REGISTRY_KEYS.PROTEIN_EXP_KEY,\n protein_expression_obsm_key,\n use_batch_mask=True,\n batch_key=batch_field.attr_key,\n colnames_uns_key=protein_names_uns_key,\n is_count_data=True,\n ),\n ]\n adata_manager = AnnDataManager(\n fields=anndata_fields, setup_method_args=setup_method_args\n )\n adata_manager.register_fields(adata, **kwargs)\n cls.register_manager(adata_manager)\n",
"import os\nimport pickle\n\nimport numpy as np\nimport pytest\nimport torch\n\nimport scvi\nfrom scvi.data import synthetic_iid\nfrom scvi.external import GIMVI\n\n\ndef test_saving_and_loading(save_path):\n def legacy_save(\n model,\n dir_path,\n prefix=None,\n overwrite=False,\n save_anndata=False,\n **anndata_write_kwargs,\n ):\n # get all the user attributes\n user_attributes = model._get_user_attributes()\n # only save the public attributes with _ at the very end\n user_attributes = {a[0]: a[1] for a in user_attributes if a[0][-1] == \"_\"}\n # save the model state dict and the trainer state dict only\n if not os.path.exists(dir_path) or overwrite:\n os.makedirs(dir_path, exist_ok=overwrite)\n else:\n raise ValueError(\n \"{} already exists. Please provide an unexisting directory for saving.\".format(\n dir_path\n )\n )\n\n file_name_prefix = prefix or \"\"\n\n if save_anndata:\n dataset_names = [\"seq\", \"spatial\"]\n for i in range(len(model.adatas)):\n dataset_name = dataset_names[i]\n save_path = os.path.join(\n dir_path, f\"{file_name_prefix}adata_{dataset_name}.h5ad\"\n )\n model.adatas[i].write(save_path)\n varnames_save_path = os.path.join(\n dir_path, f\"{file_name_prefix}var_names_{dataset_name}.csv\"\n )\n\n var_names = model.adatas[i].var_names.astype(str)\n var_names = var_names.to_numpy()\n np.savetxt(varnames_save_path, var_names, fmt=\"%s\")\n\n model_save_path = os.path.join(dir_path, f\"{file_name_prefix}model_params.pt\")\n attr_save_path = os.path.join(dir_path, f\"{file_name_prefix}attr.pkl\")\n\n torch.save(model.module.state_dict(), model_save_path)\n with open(attr_save_path, \"wb\") as f:\n pickle.dump(user_attributes, f)\n\n def test_save_and_load(save_path, legacy=False):\n prefix = \"GIMVI_\"\n adata = synthetic_iid()\n GIMVI.setup_anndata(\n adata,\n batch_key=\"batch\",\n )\n\n # GIMVI\n model = GIMVI(adata, adata)\n model.train(3, train_size=0.5)\n z1 = model.get_latent_representation([adata])\n z2 = model.get_latent_representation([adata])\n np.testing.assert_array_equal(z1, z2)\n if legacy:\n legacy_save(\n model, save_path, overwrite=True, save_anndata=True, prefix=prefix\n )\n else:\n model.save(save_path, overwrite=True, save_anndata=True, prefix=prefix)\n model = GIMVI.load(save_path, prefix=prefix)\n model.get_latent_representation()\n tmp_adata = scvi.data.synthetic_iid(n_genes=200)\n with pytest.raises(ValueError):\n GIMVI.load(\n save_path, adata_seq=tmp_adata, adata_spatial=tmp_adata, prefix=prefix\n )\n model = GIMVI.load(\n save_path, adata_seq=adata, adata_spatial=adata, prefix=prefix\n )\n z2 = model.get_latent_representation([adata])\n np.testing.assert_array_equal(z1, z2)\n model = GIMVI.load(\n save_path,\n adata_seq=adata,\n adata_spatial=adata,\n use_gpu=False,\n prefix=prefix,\n )\n z2 = model.get_latent_representation([adata])\n np.testing.assert_almost_equal(z1, z2, decimal=3)\n assert model.is_trained is True\n\n test_save_and_load(save_path, legacy=True)\n test_save_and_load(save_path)\n # Test load prioritizes newer save paradigm and thus mismatches legacy save.\n with pytest.raises(AssertionError):\n test_save_and_load(save_path, legacy=True)\n\n\ndef test_gimvi():\n adata_seq = synthetic_iid()\n adata_spatial = synthetic_iid()\n GIMVI.setup_anndata(\n adata_seq,\n batch_key=\"batch\",\n labels_key=\"labels\",\n )\n GIMVI.setup_anndata(\n adata_spatial,\n batch_key=\"batch\",\n labels_key=\"labels\",\n )\n model = GIMVI(adata_seq, adata_spatial, n_latent=10)\n assert hasattr(model.module, \"library_log_means_0\") and not hasattr(\n model.module, \"library_log_means_1\"\n )\n model.train(1, check_val_every_n_epoch=1, train_size=0.5)\n model.get_latent_representation()\n model.get_imputed_values()\n\n adata_spatial.var_names += \"asdf\"\n GIMVI.setup_anndata(\n adata_spatial,\n batch_key=\"batch\",\n labels_key=\"labels\",\n )\n with pytest.raises(ValueError):\n model = GIMVI(adata_seq, adata_spatial)\n\n\ndef test_gimvi_model_library_size():\n adata_seq = synthetic_iid()\n adata_spatial = synthetic_iid()\n GIMVI.setup_anndata(\n adata_seq,\n batch_key=\"batch\",\n labels_key=\"labels\",\n )\n GIMVI.setup_anndata(\n adata_spatial,\n batch_key=\"batch\",\n labels_key=\"labels\",\n )\n model = GIMVI(\n adata_seq, adata_spatial, model_library_size=[True, True], n_latent=10\n )\n assert hasattr(model.module, \"library_log_means_0\") and hasattr(\n model.module, \"library_log_means_1\"\n )\n model.train(1, check_val_every_n_epoch=1, train_size=0.5)\n model.get_latent_representation()\n model.get_imputed_values()\n"
] |
[
[
"numpy.random.randint"
],
[
"torch.cat",
"numpy.random.choice",
"torch.stack",
"numpy.tile",
"numpy.mean",
"torch.distributions.Bernoulli",
"torch.exp",
"numpy.concatenate",
"torch.sigmoid",
"numpy.log",
"pandas.DataFrame",
"numpy.log1p",
"numpy.arange",
"numpy.transpose",
"numpy.sqrt",
"torch.zeros_like",
"numpy.square",
"numpy.array",
"numpy.zeros",
"numpy.stack",
"numpy.argsort",
"numpy.corrcoef",
"torch.nn.functional.normalize",
"torch.distributions.Gamma",
"numpy.asarray",
"numpy.sum",
"torch.no_grad",
"scipy.stats.spearmanr",
"sklearn.mixture.GaussianMixture",
"torch.ones_like",
"torch.mean",
"numpy.unique"
],
[
"numpy.testing.assert_almost_equal",
"numpy.testing.assert_array_equal",
"numpy.savetxt"
]
] |
xiaowu0162/mobilenet_compression
|
[
"a04fa087ac84b0918fb49ef77bf8439d02cbcf1f"
] |
[
"old_code/utils.py"
] |
[
"# Copyright (c) Microsoft Corporation.\n# Licensed under the MIT license.\n\nimport os\nimport torch\nfrom torch.utils.data import Dataset\nimport torchvision.transforms as transforms\nimport numpy as np\nfrom nni.compression.pytorch.utils.counter import count_flops_params\n\nfrom mobilenet import MobileNet\nfrom mobilenet_v2 import MobileNetV2\n\n\ndef create_model(model_type=None, n_classes=120, input_size=224, checkpoint=None, pretrained=False, width_mult=1.):\n if model_type == 'mobilenet_v1':\n model = MobileNet(n_class=n_classes, profile='normal')\n elif model_type == 'mobilenet_v2':\n model = MobileNetV2(n_class=n_classes, input_size=input_size, width_mult=width_mult)\n elif model_type == 'mobilenet_v2_torchhub':\n model = torch.hub.load('pytorch/vision:v0.8.1', 'mobilenet_v2', pretrained=pretrained)\n # model = torch.hub.load('pytorch/vision:v0.10.0', 'mobilenet_v2', pretrained=pretrained)\n feature_size = model.classifier[1].weight.data.size()[1]\n replace_classifier = torch.nn.Linear(feature_size, n_classes)\n model.classifier[1] = replace_classifier\n elif model_type is None:\n model = None\n else:\n raise RuntimeError('Unknown model_type.')\n\n if checkpoint is not None:\n model.load_state_dict(torch.load(checkpoint))\n \n return model\n\n\nclass TrainDataset(Dataset):\n def __init__(self, npy_dir):\n self.root_dir = npy_dir\n self.case_names = [self.root_dir + '/' + x for x in os.listdir(self.root_dir)]\n \n transform_set = [transforms.Lambda(lambda x: x),\n transforms.RandomRotation(30),\n # transforms.RandomPerspective(),\n transforms.ColorJitter(),\n transforms.RandomHorizontalFlip(p=1)]\n self.transform = transforms.RandomChoice(transform_set)\n \n # self.transform = transforms.AutoAugment(transforms.AutoAugmentPolicy.IMAGENET)\n \n def __len__(self):\n return len(self.case_names)\n\n def __getitem__(self, index):\n instance = np.load(self.case_names[index], allow_pickle=True).item()\n x = instance['input'].transpose(2, 0, 1) # (C, H, W)\n x = torch.from_numpy(x).type(torch.float)#.type(torch.uint8) # convert to Tensor to use torchvision.transforms\n x = self.transform(x)\n return x, instance['label']\n\n\nclass EvalDataset(Dataset):\n def __init__(self, npy_dir):\n self.root_dir = npy_dir\n self.case_names = [self.root_dir + '/' + x for x in os.listdir(self.root_dir)]\n\n def __len__(self):\n return len(self.case_names)\n\n def __getitem__(self, index):\n instance = np.load(self.case_names[index], allow_pickle=True).item()\n x = instance['input'].transpose(2, 0, 1)\n x = torch.from_numpy(x).type(torch.float) #.type(torch.uint8)\n return x, instance['label']\n\n\ndef count_flops(model, log=None):\n dummy_input = torch.rand([1, 3, 256, 256])\n flops, params, results = count_flops_params(model, dummy_input)\n print(f\"FLOPs: {flops}, params: {params}\")\n if log is not None:\n log.write(f\"FLOPs: {flops}, params: {params}\\n\")\n return flops, params\n"
] |
[
[
"torch.nn.Linear",
"torch.rand",
"numpy.load",
"torch.from_numpy",
"torch.load",
"torch.hub.load"
]
] |
LindgeW/AT4MTL
|
[
"8fe0f142f830b7f2cb170ffe53ec535ca5bb3eab"
] |
[
"modules/grl.py"
] |
[
"import torch\n\n\n# Gradient Reversal Layer\nclass GRLayer(torch.autograd.Function):\n @staticmethod\n def forward(ctx, x, lmbd=0.01):\n ctx.lmbd = torch.tensor(lmbd)\n return x.reshape_as(x)\n\n @staticmethod\n # 输入为forward输出的梯度\n def backward(ctx, grad_output):\n grad_input = grad_output.clone()\n return ctx.lmbd * grad_input.neg(), None\n"
] |
[
[
"torch.tensor"
]
] |
akobiisr/wetectron
|
[
"9973eb4f1716fbc5f46b41a7f93fb1f1c78bc8c7"
] |
[
"wetectron/modeling/rpn/retinanet/inference.py"
] |
[
"import torch\n\nfrom ..inference import RPNPostProcessor\nfrom ..utils import permute_and_flatten\n\nfrom wetectron.modeling.box_coder import BoxCoder\nfrom wetectron.modeling.utils import cat\nfrom wetectron.structures.bounding_box import BoxList\nfrom wetectron.structures.boxlist_ops import cat_boxlist\nfrom wetectron.structures.boxlist_ops import boxlist_nms\nfrom wetectron.structures.boxlist_ops import remove_small_boxes\n\n\nclass RetinaNetPostProcessor(RPNPostProcessor):\n \"\"\"\n Performs post-processing on the outputs of the RetinaNet boxes.\n This is only used in the testing.\n \"\"\"\n def __init__(\n self,\n pre_nms_thresh,\n pre_nms_top_n,\n nms_thresh,\n fpn_post_nms_top_n,\n min_size,\n num_classes,\n box_coder=None,\n ):\n \"\"\"\n Arguments:\n pre_nms_thresh (float)\n pre_nms_top_n (int)\n nms_thresh (float)\n fpn_post_nms_top_n (int)\n min_size (int)\n num_classes (int)\n box_coder (BoxCoder)\n \"\"\"\n super(RetinaNetPostProcessor, self).__init__(\n pre_nms_thresh, 0, nms_thresh, min_size\n )\n self.pre_nms_thresh = pre_nms_thresh\n self.pre_nms_top_n = pre_nms_top_n\n self.nms_thresh = nms_thresh\n self.fpn_post_nms_top_n = fpn_post_nms_top_n\n self.min_size = min_size\n self.num_classes = num_classes\n\n if box_coder is None:\n box_coder = BoxCoder(weights=(10., 10., 5., 5.))\n self.box_coder = box_coder\n \n def add_gt_proposals(self, proposals, targets):\n \"\"\"\n This function is not used in RetinaNet\n \"\"\"\n pass\n\n def forward_for_single_feature_map(\n self, anchors, box_cls, box_regression):\n \"\"\"\n Arguments:\n anchors: list[BoxList]\n box_cls: tensor of size N, A * C, H, W\n box_regression: tensor of size N, A * 4, H, W\n \"\"\"\n device = box_cls.device\n N, _, H, W = box_cls.shape\n A = box_regression.size(1) // 4\n C = box_cls.size(1) // A\n\n # put in the same format as anchors\n box_cls = permute_and_flatten(box_cls, N, A, C, H, W)\n box_cls = box_cls.sigmoid()\n\n box_regression = permute_and_flatten(box_regression, N, A, 4, H, W)\n box_regression = box_regression.reshape(N, -1, 4)\n\n num_anchors = A * H * W\n\n candidate_inds = box_cls > self.pre_nms_thresh\n\n pre_nms_top_n = candidate_inds.view(N, -1).sum(1)\n pre_nms_top_n = pre_nms_top_n.clamp(max=self.pre_nms_top_n)\n\n results = []\n for per_box_cls, per_box_regression, per_pre_nms_top_n, \\\n per_candidate_inds, per_anchors in zip(\n box_cls,\n box_regression,\n pre_nms_top_n,\n candidate_inds,\n anchors):\n\n # Sort and select TopN\n # TODO most of this can be made out of the loop for\n # all images. \n # TODO:Yang: Not easy to do. Because the numbers of detections are\n # different in each image. Therefore, this part needs to be done\n # per image. \n per_box_cls = per_box_cls[per_candidate_inds]\n \n per_box_cls, top_k_indices = \\\n per_box_cls.topk(per_pre_nms_top_n, sorted=False)\n\n per_candidate_nonzeros = \\\n per_candidate_inds.nonzero()[top_k_indices, :]\n\n per_box_loc = per_candidate_nonzeros[:, 0]\n per_class = per_candidate_nonzeros[:, 1]\n per_class += 1\n\n detections = self.box_coder.decode(\n per_box_regression[per_box_loc, :].view(-1, 4),\n per_anchors.bbox[per_box_loc, :].view(-1, 4)\n )\n\n boxlist = BoxList(detections, per_anchors.size, mode=\"xyxy\")\n boxlist.add_field(\"labels\", per_class)\n boxlist.add_field(\"scores\", per_box_cls)\n boxlist = boxlist.clip_to_image(remove_empty=False)\n boxlist = remove_small_boxes(boxlist, self.min_size)\n results.append(boxlist)\n\n return results\n\n # TODO very similar to filter_results from PostProcessor\n # but filter_results is per image\n # TODO Yang: solve this issue in the future. No good solution\n # right now.\n def select_over_all_levels(self, boxlists):\n num_images = len(boxlists)\n results = []\n for i in range(num_images):\n scores = boxlists[i].get_field(\"scores\")\n labels = boxlists[i].get_field(\"labels\")\n boxes = boxlists[i].bbox\n boxlist = boxlists[i]\n result = []\n # skip the background\n for j in range(1, self.num_classes):\n inds = (labels == j).nonzero().view(-1)\n\n scores_j = scores[inds]\n boxes_j = boxes[inds, :].view(-1, 4)\n boxlist_for_class = BoxList(boxes_j, boxlist.size, mode=\"xyxy\")\n boxlist_for_class.add_field(\"scores\", scores_j)\n boxlist_for_class = boxlist_nms(\n boxlist_for_class, self.nms_thresh,\n score_field=\"scores\"\n )\n num_labels = len(boxlist_for_class)\n boxlist_for_class.add_field(\n \"labels\", torch.full((num_labels,), j,\n dtype=torch.int64,\n device=scores.device)\n )\n result.append(boxlist_for_class)\n\n result = cat_boxlist(result)\n number_of_detections = len(result)\n\n # Limit to max_per_image detections **over all classes**\n if number_of_detections > self.fpn_post_nms_top_n > 0:\n cls_scores = result.get_field(\"scores\")\n image_thresh, _ = torch.kthvalue(\n cls_scores.cpu(),\n number_of_detections - self.fpn_post_nms_top_n + 1\n )\n keep = cls_scores >= image_thresh.item()\n keep = torch.nonzero(keep).squeeze(1)\n result = result[keep]\n results.append(result)\n return results\n\n\ndef make_retinanet_postprocessor(config, rpn_box_coder, is_train):\n pre_nms_thresh = config.MODEL.RETINANET.INFERENCE_TH\n pre_nms_top_n = config.MODEL.RETINANET.PRE_NMS_TOP_N\n nms_thresh = config.MODEL.RETINANET.NMS_TH\n fpn_post_nms_top_n = config.TEST.DETECTIONS_PER_IMG\n min_size = 0\n\n box_selector = RetinaNetPostProcessor(\n pre_nms_thresh=pre_nms_thresh,\n pre_nms_top_n=pre_nms_top_n,\n nms_thresh=nms_thresh,\n fpn_post_nms_top_n=fpn_post_nms_top_n,\n min_size=min_size,\n num_classes=config.MODEL.RETINANET.NUM_CLASSES,\n box_coder=rpn_box_coder,\n )\n\n return box_selector\n"
] |
[
[
"torch.nonzero",
"torch.full"
]
] |
tjbanks/bmtk
|
[
"52fee3b230ceb14a666c46f57f2031c38f1ac5b1",
"52fee3b230ceb14a666c46f57f2031c38f1ac5b1"
] |
[
"bmtk/tests/utils/reports/spike_trains/test_file_writers.py",
"bmtk/tests/utils/reports/spike_trains/create_files.py"
] |
[
"import os\nimport pytest\nimport numpy as np\nimport pandas as pd\nimport h5py\n\nfrom bmtk.utils.reports.spike_trains import SpikeTrains, sort_order, pop_na\nfrom bmtk.utils.reports.spike_trains import write_csv\nfrom bmtk.utils.reports.spike_trains import write_sonata\n\n\ndef load_spike_trains(file_path):\n cpath = os.path.dirname(os.path.realpath(__file__))\n file_path = os.path.join(cpath, file_path)\n if file_path.endswith('.csv'):\n return SpikeTrains.from_csv(file_path)\n\n elif file_path.endswith('.h5'):\n return SpikeTrains.from_sonata(file_path)\n\n elif file_path.endswith('.nwb'):\n return SpikeTrains.from_nwb(file_path)\n\n\n@pytest.mark.parametrize('input_path,pop_name',\n [\n ('spike_files/spikes.noheader.nopop.csv', pop_na),\n ('spike_files/spikes.one_pop.csv', 'v1'),\n ('spike_files/spikes.old.h5', pop_na),\n ('spike_files/spikes.one_pop.h5', 'v1'),\n ('spike_files/spikes.onepop.v1.0.nwb', pop_na)\n ])\ndef test_csv_writer_onepop(input_path, pop_name):\n spikes = load_spike_trains(input_path)\n output_path = 'output/tmpspikes.csv'\n write_csv(path=output_path, spiketrain_reader=spikes, sort_order=sort_order.by_time)\n output_df = pd.read_csv(output_path, sep=' ')\n assert(len(output_df) == 124)\n assert(output_df['population'].unique() == [pop_name])\n assert(np.all(np.diff(output_df['timestamps']) >= 0))\n\n write_csv(path=output_path, spiketrain_reader=spikes, sort_order=sort_order.by_id)\n output_df = pd.read_csv(output_path, sep=' ')\n assert(len(output_df) == 124)\n assert(np.all(np.diff(output_df['node_ids']) >= 0))\n\n\n@pytest.mark.parametrize('input_path',\n [\n ('spike_files/spikes.multipop.csv'),\n ('spike_files/spikes.multipop.h5')\n ])\ndef test_csv_writer_multipop(input_path):\n spikes = load_spike_trains(input_path)\n output_path = 'output/tmpspikes.csv'\n write_csv(path=output_path, spiketrain_reader=spikes, sort_order=sort_order.by_time)\n output_df = pd.read_csv(output_path, sep=' ')\n assert(len(output_df) == 144434)\n assert(np.all(np.diff(output_df['timestamps']) >= 0))\n os.remove(output_path)\n\n write_csv(path=output_path, spiketrain_reader=spikes, sort_order=sort_order.by_id)\n output_df = pd.read_csv(output_path, sep=' ')\n assert(len(output_df) == 144434)\n output_lgn = output_df[output_df['population'] == 'v1']\n assert(np.all(np.diff(output_lgn['node_ids']) >= 0))\n output_tw = output_df[output_df['population'] == 'tw']\n assert(np.all(np.diff(output_tw['node_ids']) >= 0))\n os.remove(output_path)\n\n\n@pytest.mark.parametrize('input_path,pop_name',\n [\n ('spike_files/spikes.noheader.nopop.csv', pop_na),\n ('spike_files/spikes.one_pop.csv', 'v1'),\n ('spike_files/spikes.old.h5', pop_na),\n ('spike_files/spikes.one_pop.h5', 'v1'),\n ('spike_files/spikes.onepop.v1.0.nwb', pop_na)\n ])\ndef test_sonata_writer_onepop(input_path, pop_name):\n spikes = load_spike_trains(input_path)\n output_path = 'output/tmpspikes.h5'\n write_sonata(path=output_path, spiketrain_reader=spikes, sort_order=sort_order.by_time)\n spikes_h5 = h5py.File(output_path, 'r')\n spikes_grp = spikes_h5['/spikes/{}'.format(pop_name)]\n assert(spikes_grp.attrs['sorting'] == 'by_time')\n timestamps = spikes_grp['timestamps'][()]\n assert(len(timestamps) == 124)\n assert(np.all(np.diff(timestamps) >= 0))\n node_ids = spikes_grp['node_ids'][()]\n assert(len(node_ids) == 124)\n os.remove(output_path)\n\n write_sonata(path=output_path, spiketrain_reader=spikes, sort_order=sort_order.by_id)\n spikes_h5 = h5py.File(output_path, 'r')\n spikes_grp = spikes_h5['/spikes/{}'.format(pop_name)]\n assert(spikes_grp.attrs['sorting'] == 'by_id')\n timestamps = spikes_grp['timestamps'][()]\n assert(len(timestamps) == 124)\n node_ids = spikes_grp['node_ids'][()]\n assert(np.all(np.diff(node_ids) >= 0))\n assert(len(node_ids) == 124)\n os.remove(output_path)\n\n\n@pytest.mark.parametrize('input_path',\n [\n ('spike_files/spikes.multipop.csv'),\n ('spike_files/spikes.multipop.h5')\n ])\ndef test_sonata_writer_multipop(input_path):\n spikes = load_spike_trains(input_path)\n output_path = 'output/tmpspikes.h5'\n write_sonata(path=output_path, spiketrain_reader=spikes, sort_order=sort_order.by_time)\n spikes_h5 = h5py.File(output_path, 'r')\n lgn_spikes = spikes_h5['/spikes/lgn']\n lgn_timestamps = lgn_spikes['timestamps'][()]\n assert(len(lgn_timestamps) == 123356)\n assert(np.all(np.diff(lgn_timestamps) >= 0))\n assert(len(lgn_spikes['node_ids']) == 123356)\n assert(len(spikes_h5['/spikes/tw/timestamps']) == 21078)\n assert(len(spikes_h5['/spikes/tw/node_ids']) == 21078)\n os.remove(output_path)\n\n write_sonata(path=output_path, spiketrain_reader=spikes, sort_order=sort_order.by_id)\n spikes_h5 = h5py.File(output_path, 'r')\n lgn_spikes = spikes_h5['/spikes/lgn']\n lgn_node_ids = lgn_spikes['node_ids'][()]\n assert(len(lgn_node_ids) == 123356)\n assert(np.all(np.diff(lgn_node_ids) >= 0))\n assert(len(lgn_spikes['timestamps']) == 123356)\n assert(len(spikes_h5['/spikes/tw/timestamps']))\n assert(len(spikes_h5['/spikes/tw/node_ids']))\n os.remove(output_path)\n\n\ndef update(n=14):\n for i in range(n):\n print('{} of {}'.format(i+1, n))\n yield\n\n\nif __name__ == '__main__':\n prnt_stmt = update()\n test_csv_writer_onepop('spike_files/spikes.noheader.nopop.csv', pop_name=pop_na); next(prnt_stmt)\n test_csv_writer_onepop('spike_files/spikes.one_pop.csv', pop_name='v1'); next(prnt_stmt)\n test_csv_writer_onepop('spike_files/spikes.old.h5', pop_name=pop_na); next(prnt_stmt)\n test_csv_writer_onepop('spike_files/spikes.one_pop.h5', pop_name='v1'); next(prnt_stmt)\n test_csv_writer_onepop('spike_files/spikes.onepop.v1.0.nwb', pop_name=pop_na); next(prnt_stmt)\n\n test_csv_writer_multipop('spike_files/spikes.multipop.csv'); next(prnt_stmt)\n test_csv_writer_multipop('spike_files/spikes.multipop.h5'); next(prnt_stmt)\n\n test_sonata_writer_onepop('spike_files/spikes.noheader.nopop.csv', pop_name=pop_na); next(prnt_stmt)\n test_sonata_writer_onepop('spike_files/spikes.one_pop.csv', pop_name='v1'); next(prnt_stmt)\n test_sonata_writer_onepop('spike_files/spikes.old.h5', pop_name=pop_na); next(prnt_stmt)\n test_sonata_writer_onepop('spike_files/spikes.one_pop.h5', pop_name='v1'); next(prnt_stmt)\n test_sonata_writer_onepop('spike_files/spikes.onepop.v1.0.nwb', pop_name=pop_na); next(prnt_stmt)\n\n test_sonata_writer_multipop('spike_files/spikes.multipop.csv'); next(prnt_stmt)\n test_sonata_writer_multipop('spike_files/spikes.multipop.h5'); next(prnt_stmt)\n",
"import os\nimport numpy as np\nimport pandas as pd\nimport h5py\n\nfrom bmtk.utils.sonata.utils import add_hdf5_magic, add_hdf5_version\n\n\ndef create_single_pop_h5():\n h5_file_old = h5py.File('spike_files/spikes.old.h5', 'r')\n node_ids = h5_file_old['/spikes/gids']\n timestamps = h5_file_old['/spikes/timestamps']\n\n with h5py.File('spike_files/spikes.one_pop.h5', 'w') as h5:\n add_hdf5_magic(h5)\n add_hdf5_version(h5)\n core_grp = h5.create_group('/spikes/v1')\n core_grp.attrs['sorting'] = 'by_time'\n ts_ds = core_grp.create_dataset('timestamps', data=timestamps, dtype=np.float64)\n ts_ds.attrs['units'] = 'milliseconds'\n nids_ds = core_grp.create_dataset('node_ids', data=node_ids, dtype=np.uint64)\n\n\ndef create_multipop_csv(dir_path='/local1/workspace/bmtk/docs/examples/NWB_files'):\n lgn_h5 = h5py.File(os.path.join(dir_path, 'lgn_spikes.nwb'), 'r')\n tw_h5 = h5py.File(os.path.join(dir_path, 'tw_spikes.nwb'), 'r')\n\n full_df = pd.DataFrame({\n 'timestamps': pd.Series(dtype=np.float64),\n 'population': pd.Series(dtype=np.string_),\n 'node_ids': pd.Series(dtype=np.uint64)\n })\n\n for pop_name, pop_h5, n_nodes in [('lgn', lgn_h5, 4000), ('tw', tw_h5, 2000)]:\n spike_train_grp = pop_h5['/processing/trial_0/spike_train']\n for node_id in range(n_nodes):\n tmp_df = pd.DataFrame({\n 'timestamps': spike_train_grp[str(node_id)]['data'][()],\n 'population': pop_name,\n 'node_ids': np.uint64(node_id)\n })\n\n full_df = full_df.append(tmp_df)\n\n full_df = full_df[['timestamps', 'population', 'node_ids']]\n full_df.to_csv('spike_files/spikes.multipop.csv', sep=' ', index=False)\n\n\ndef create_multipop_h5():\n spikes_df = pd.read_csv('spike_files/spikes.multipop.csv', sep=' ')\n lgn_spikes_df = spikes_df[spikes_df['population'] == 'lgn']\n tw_spikes_df = spikes_df[spikes_df['population'] == 'tw']\n with h5py.File('spike_files/spikes.multipop.h5', 'w') as h5:\n add_hdf5_magic(h5)\n add_hdf5_version(h5)\n\n lgn_grp = h5.create_group('/spikes/lgn')\n lgn_grp.attrs['sorting'] = 'by_id'\n ts_ds = lgn_grp.create_dataset('timestamps', data=lgn_spikes_df['timestamps'], dtype=np.float64)\n ts_ds.attrs['units'] = 'milliseconds'\n lgn_grp.create_dataset('node_ids', data=lgn_spikes_df['node_ids'], dtype=np.uint64)\n\n\n tw_grp = h5.create_group('/spikes/tw')\n tw_grp.attrs['sorting'] = 'by_id'\n ts_ds = tw_grp.create_dataset('timestamps', data=tw_spikes_df['timestamps'], dtype=np.float64)\n ts_ds.attrs['units'] = 'milliseconds'\n tw_grp.create_dataset('node_ids', data=tw_spikes_df['node_ids'], dtype=np.uint64)\n\n\ndef create_nwb():\n spikes_df = pd.read_csv('spike_files/spikes.one_pop.csv', sep=' ')\n with h5py.File('spike_files/spikes.onepop.v1.0.nwb', 'w') as h5:\n spikes_grp = h5.create_group('/processing/trial_0/spike_train')\n for node_id in range(14):\n timestamps = spikes_df[spikes_df['node_ids'] == node_id]['timestamps'].values\n data_ds = spikes_grp.create_dataset('{}/data'.format(node_id), data=timestamps, dtype=np.float64)\n data_ds.attrs['dimension'] = 'time'\n data_ds.attrs['unit'] = 'millisecond'\n\n\n\nif __name__ == '__main__':\n # create_multipop_csv()\n # create_multipop_h5()\n create_nwb()\n\n\n"
] |
[
[
"pandas.read_csv",
"numpy.diff"
],
[
"numpy.uint64",
"pandas.read_csv",
"pandas.Series"
]
] |
joaofonseca9/mimic3-benchmarks-TBI_edit
|
[
"21533b011433272b06d970fa47fe1c8cbfeb5351"
] |
[
"mimic3benchmark/preprocessing.py"
] |
[
"from __future__ import absolute_import\nfrom __future__ import print_function\n\nimport numpy as np\nimport re\n\nfrom pandas import DataFrame, Series\n\nfrom mimic3benchmark.util import dataframe_from_csv\n\n###############################\n# Non-time series preprocessing\n###############################\n\ng_map = {'F': 1, 'M': 2, 'OTHER': 3, '': 0}\n\n\ndef transform_gender(gender_series):\n global g_map\n return {'Gender': gender_series.fillna('').apply(lambda s: g_map[s] if s in g_map else g_map['OTHER'])}\n\n\ne_map = {'ASIAN': 1,\n 'BLACK': 2,\n 'CARIBBEAN ISLAND': 2,\n 'HISPANIC': 3,\n 'SOUTH AMERICAN': 3,\n 'WHITE': 4,\n 'MIDDLE EASTERN': 4,\n 'PORTUGUESE': 4,\n 'AMERICAN INDIAN': 0,\n 'NATIVE HAWAIIAN': 0,\n 'UNABLE TO OBTAIN': 0,\n 'PATIENT DECLINED TO ANSWER': 0,\n 'UNKNOWN': 0,\n 'OTHER': 0,\n '': 0}\n\n\ndef transform_ethnicity(ethnicity_series):\n global e_map\n\n def aggregate_ethnicity(ethnicity_str):\n return ethnicity_str.replace(' OR ', '/').split(' - ')[0].split('/')[0]\n\n ethnicity_series = ethnicity_series.apply(aggregate_ethnicity)\n return {'Ethnicity': ethnicity_series.fillna('').apply(lambda s: e_map[s] if s in e_map else e_map['OTHER'])}\n\n\ndef assemble_episodic_data(stays, diagnoses):\n data = {'Icustay': stays.ICUSTAY_ID, 'Age': stays.AGE, 'Length of Stay': stays.LOS,\n 'Mortality': stays.MORTALITY}\n data.update(transform_gender(stays.GENDER))\n data.update(transform_ethnicity(stays.ETHNICITY))\n data['Height'] = np.nan\n data['Weight'] = np.nan\n data = DataFrame(data).set_index('Icustay')\n data = data[['Ethnicity', 'Gender', 'Age', 'Height', 'Weight', 'Length of Stay', 'Mortality']]\n return data.merge(extract_diagnosis_labels(diagnoses), left_index=True, right_index=True)\n\n\ndiagnosis_labels = ['4019', '4280', '41401', '42731', '25000', '5849', '2724', '51881', '53081', '5990', '2720',\n '2859', '2449', '486', '2762', '2851', '496', 'V5861', '99592', '311', '0389', '5859', '5070',\n '40390', '3051', '412', 'V4581', '2761', '41071', '2875', '4240', 'V1582', 'V4582', 'V5867',\n '4241', '40391', '78552', '5119', '42789', '32723', '49390', '9971', '2767', '2760', '2749',\n '4168', '5180', '45829', '4589', '73300', '5845', '78039', '5856', '4271', '4254', '4111',\n 'V1251', '30000', '3572', '60000', '27800', '41400', '2768', '4439', '27651', 'V4501', '27652',\n '99811', '431', '28521', '2930', '7907', 'E8798', '5789', '79902', 'V4986', 'V103', '42832',\n 'E8788', '00845', '5715', '99591', '07054', '42833', '4275', '49121', 'V1046', '2948', '70703',\n '2809', '5712', '27801', '42732', '99812', '4139', '3004', '2639', '42822', '25060', 'V1254',\n '42823', '28529', 'E8782', '30500', '78791', '78551', 'E8889', '78820', '34590', '2800', '99859',\n 'V667', 'E8497', '79092', '5723', '3485', '5601', '25040', '570', '71590', '2869', '2763', '5770',\n 'V5865', '99662', '28860', '36201', '56210']\n\n\ndef extract_diagnosis_labels(diagnoses):\n global diagnosis_labels\n diagnoses['VALUE'] = 1\n labels = diagnoses[['ICUSTAY_ID', 'ICD9_CODE', 'VALUE']].drop_duplicates()\\\n .pivot(index='ICUSTAY_ID', columns='ICD9_CODE', values='VALUE').fillna(0).astype(int)\n for l in diagnosis_labels:\n if l not in labels:\n labels[l] = 0\n labels = labels[diagnosis_labels]\n return labels.rename(dict(zip(diagnosis_labels, ['Diagnosis ' + d for d in diagnosis_labels])), axis=1)\n\n\ndef add_hcup_ccs_2015_groups(diagnoses, definitions):\n def_map = {}\n for dx in definitions:\n for code in definitions[dx]['codes']:\n def_map[code] = (dx, definitions[dx]['use_in_benchmark'])\n diagnoses['HCUP_CCS_2015'] = diagnoses.ICD9_CODE.apply(lambda c: def_map[c][0] if c in def_map else None)\n diagnoses['USE_IN_BENCHMARK'] = diagnoses.ICD9_CODE.apply(lambda c: int(def_map[c][1]) if c in def_map else None)\n return diagnoses\n\n\ndef make_phenotype_label_matrix(phenotypes, stays=None):\n phenotypes = phenotypes[['ICUSTAY_ID', 'HCUP_CCS_2015']].loc[phenotypes.USE_IN_BENCHMARK > 0].drop_duplicates()\n phenotypes['VALUE'] = 1\n phenotypes = phenotypes.pivot(index='ICUSTAY_ID', columns='HCUP_CCS_2015', values='VALUE')\n if stays is not None:\n phenotypes = phenotypes.reindex(stays.ICUSTAY_ID.sort_values())\n return phenotypes.fillna(0).astype(int).sort_index(axis=0).sort_index(axis=1)\n\n\n###################################\n# Time series preprocessing\n###################################\n\ndef read_itemid_to_variable_map(fn, variable_column='LEVEL2', added_fts=False):\n var_map = dataframe_from_csv(fn, index_col=None, header=0).fillna('').astype(str)\n # var_map[variable_column] = var_map[variable_column].apply(lambda s: s.lower())\n var_map.COUNT = var_map.COUNT.astype(float).astype(int)\n var_map = var_map[(var_map[variable_column] != '') & (var_map.COUNT > 0)]\n if added_fts:\n var_map = var_map[((var_map.STATUS == 'ready') | (var_map.STATUS == 'verify')) & (var_map.COUNT > 258343)]\n else:\n var_map = var_map[(var_map.STATUS == 'ready')]\n var_map.ITEMID = var_map.ITEMID.astype(float).astype(int)\n var_map = var_map[[variable_column, 'ITEMID', 'MIMIC LABEL']].set_index('ITEMID')\n return var_map.rename({variable_column: 'VARIABLE', 'MIMIC LABEL': 'MIMIC_LABEL'}, axis=1)\n\n\ndef map_itemids_to_variables(events, var_map):\n return events.merge(var_map, left_on='ITEMID', right_index=True)\n\n\ndef read_variable_ranges(fn, variable_column='LEVEL2'):\n columns = [variable_column, 'OUTLIER LOW', 'VALID LOW', 'IMPUTE', 'VALID HIGH', 'OUTLIER HIGH']\n to_rename = dict(zip(columns, [c.replace(' ', '_') for c in columns]))\n to_rename[variable_column] = 'VARIABLE'\n var_ranges = dataframe_from_csv(fn, index_col=None)\n # var_ranges = var_ranges[variable_column].apply(lambda s: s.lower())\n var_ranges = var_ranges[columns]\n var_ranges.rename(to_rename, axis=1, inplace=True)\n var_ranges = var_ranges.drop_duplicates(subset='VARIABLE', keep='first')\n var_ranges.set_index('VARIABLE', inplace=True)\n return var_ranges.loc[var_ranges.notnull().all(axis=1)]\n\n\ndef remove_outliers_for_variable(events, variable, ranges):\n if variable not in ranges.index:\n return events\n idx = (events.VARIABLE == variable)\n v = events.VALUE[idx].copy()\n v.loc[v < ranges.OUTLIER_LOW[variable]] = np.nan\n v.loc[v > ranges.OUTLIER_HIGH[variable]] = np.nan\n v.loc[v < ranges.VALID_LOW[variable]] = ranges.VALID_LOW[variable]\n v.loc[v > ranges.VALID_HIGH[variable]] = ranges.VALID_HIGH[variable]\n events.loc[idx, 'VALUE'] = v\n return events\n\n\n# SBP: some are strings of type SBP/DBP\ndef clean_sbp(df):\n v = df.VALUE.astype(str).copy()\n idx = v.apply(lambda s: '/' in s)\n v.loc[idx] = v[idx].apply(lambda s: re.match('^(\\d+)/(\\d+)$', s).group(1))\n return v.astype(float)\n\n\ndef clean_dbp(df):\n v = df.VALUE.astype(str).copy()\n idx = v.apply(lambda s: '/' in s)\n v.loc[idx] = v[idx].apply(lambda s: re.match('^(\\d+)/(\\d+)$', s).group(2))\n return v.astype(float)\n\n\n# CRR: strings with brisk, <3 normal, delayed, or >3 abnormal\ndef clean_crr(df):\n v = Series(np.zeros(df.shape[0]), index=df.index)\n v[:] = np.nan\n\n # when df.VALUE is empty, dtype can be float and comparision with string\n # raises an exception, to fix this we change dtype to str\n df_value_str = df.VALUE.astype(str)\n\n v.loc[(df_value_str == 'Normal <3 secs') | (df_value_str == 'Brisk')] = 0\n v.loc[(df_value_str == 'Abnormal >3 secs') | (df_value_str == 'Delayed')] = 1\n return v\n\n\n# FIO2: many 0s, some 0<x<0.2 or 1<x<20\ndef clean_fio2(df):\n v = df.VALUE.astype(float).copy()\n\n ''' The line below is the correct way of doing the cleaning, since we will not compare 'str' to 'float'.\n If we use that line it will create mismatches from the data of the paper in ~50 ICU stays.\n The next releases of the benchmark should use this line.\n '''\n # idx = df.VALUEUOM.fillna('').apply(lambda s: 'torr' not in s.lower()) & (v>1.0)\n\n ''' The line below was used to create the benchmark dataset that the paper used. Note this line will not work\n in python 3, since it may try to compare 'str' to 'float'.\n '''\n # idx = df.VALUEUOM.fillna('').apply(lambda s: 'torr' not in s.lower()) & (df.VALUE > 1.0)\n\n ''' The two following lines implement the code that was used to create the benchmark dataset that the paper used.\n This works with both python 2 and python 3.\n '''\n is_str = np.array(map(lambda x: type(x) == str, list(df.VALUE)), dtype=np.bool)\n idx = df.VALUEUOM.fillna('').apply(lambda s: 'torr' not in s.lower()) & (is_str | (~is_str & (v > 1.0)))\n\n v.loc[idx] = v[idx] / 100.\n return v\n\n\n# GLUCOSE, PH: sometimes have ERROR as value\ndef clean_lab(df):\n v = df.VALUE.copy()\n idx = v.apply(lambda s: type(s) is str and not re.match('^(\\d+(\\.\\d*)?|\\.\\d+)$', s))\n v.loc[idx] = np.nan\n return v.astype(float)\n\n\n# O2SAT: small number of 0<x<=1 that should be mapped to 0-100 scale\ndef clean_o2sat(df):\n # change \"ERROR\" to NaN\n v = df.VALUE.copy()\n idx = v.apply(lambda s: type(s) is str and not re.match('^(\\d+(\\.\\d*)?|\\.\\d+)$', s))\n v.loc[idx] = np.nan\n\n v = v.astype(float)\n idx = (v <= 1)\n v.loc[idx] = v[idx] * 100.\n return v\n\n\n# Temperature: map Farenheit to Celsius, some ambiguous 50<x<80\ndef clean_temperature(df):\n v = df.VALUE.astype(float).copy()\n idx = df.VALUEUOM.fillna('').apply(lambda s: 'F' in s.lower()) | df.MIMIC_LABEL.apply(lambda s: 'F' in s.lower()) | (v >= 79)\n v.loc[idx] = (v[idx] - 32) * 5. / 9\n return v\n\n\n# Weight: some really light/heavy adults: <50 lb, >450 lb, ambiguous oz/lb\n# Children are tough for height, weight\ndef clean_weight(df):\n v = df.VALUE.astype(float).copy()\n # ounces\n idx = df.VALUEUOM.fillna('').apply(lambda s: 'oz' in s.lower()) | df.MIMIC_LABEL.apply(lambda s: 'oz' in s.lower())\n v.loc[idx] = v[idx] / 16.\n # pounds\n idx = idx | df.VALUEUOM.fillna('').apply(lambda s: 'lb' in s.lower()) | df.MIMIC_LABEL.apply(lambda s: 'lb' in s.lower())\n v.loc[idx] = v[idx] * 0.453592\n return v\n\n\n# Height: some really short/tall adults: <2 ft, >7 ft)\n# Children are tough for height, weight\ndef clean_height(df):\n v = df.VALUE.astype(float).copy()\n idx = df.VALUEUOM.fillna('').apply(lambda s: 'in' in s.lower()) | df.MIMIC_LABEL.apply(lambda s: 'in' in s.lower())\n v.loc[idx] = np.round(v[idx] * 2.54)\n return v\n\n# Potassium: one value was misimputed as '10k' instead of 10\ndef clean_potassium(df):\n v = df.VALUE.copy()\n for value in v:\n if value =='10k':\n value='10'\n return v\n\n\n# ETCO2: haven't found yet\n# Urine output: ambiguous units (raw ccs, ccs/kg/hr, 24-hr, etc.)\n# Tidal volume: tried to substitute for ETCO2 but units are ambiguous\n# Glascow coma scale eye opening\n# Glascow coma scale motor response\n# Glascow coma scale total\n# Glascow coma scale verbal response\n# Heart Rate\n# Respiratory rate\n# Mean blood pressure\nclean_fns = {\n 'Capillary refill rate': clean_crr,\n 'Diastolic blood pressure': clean_dbp,\n 'Systolic blood pressure': clean_sbp,\n 'Fraction inspired oxygen': clean_fio2,\n 'Oxygen saturation': clean_o2sat,\n 'Glucose': clean_lab,\n 'pH': clean_lab,\n 'Temperature': clean_temperature,\n 'Weight': clean_weight,\n 'Height': clean_height,\n 'Potassium': clean_potassium\n}\n\n\ndef clean_events(events):\n global clean_fns\n for var_name, clean_fn in clean_fns.items():\n idx = (events.VARIABLE == var_name)\n try:\n events.loc[idx, 'VALUE'] = clean_fn(events[idx])\n except Exception as e:\n import traceback\n print(\"Exception in clean_events:\", clean_fn.__name__, e)\n print(traceback.format_exc())\n print(\"number of rows:\", np.sum(idx))\n print(\"values:\", events[idx])\n exit()\n return events.loc[events.VALUE.notnull()]\n"
] |
[
[
"numpy.round",
"pandas.DataFrame",
"numpy.sum",
"numpy.zeros"
]
] |
zhangqianhui/FUNIT_tensorflow
|
[
"16ea70e881d4aa2d38cd44c0fcb60f4ed821a24d"
] |
[
"FUNIT.py"
] |
[
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom tfLib.ops import *\nfrom tfLib.loss import *\nfrom Dataset import save_images\nimport os\nimport numpy as np\nimport PyLib.const as con\n\ncon.EPS = 1e-7\nclass FSUGAN(object):\n\n # build model\n def __init__(self, data_ob, opt):\n\n self.opt = opt\n # placeholder defination\n self.data_ob = data_ob\n self.x = tf.placeholder(tf.float32,[opt.batchSize, opt.image_size, opt.image_size, opt.input_nc])\n self.y_1 = tf.placeholder(tf.float32,[opt.batchSize, opt.image_size, opt.image_size, opt.input_nc])\n self.cls_x = tf.placeholder(tf.int32, [opt.batchSize])\n self.cls_y = tf.placeholder(tf.int32, [opt.batchSize])\n self.lr_decay = tf.placeholder(tf.float32, None, name='lr_decay')\n\n def build_model(self):\n\n self.content_code = self.content_encoder(self.x)\n self.encode_y1 = self.class_encoder_k(self.y_1)\n self.class_code = self.encode_y1\n self.tilde_x = self.decoder(content_code=self.content_code, class_code=self.class_code)\n self.encode_x = self.class_encoder_k(self.x)\n self.x_recon = self.decoder(content_code=self.content_code, class_code=self.encode_x)\n self.content_recon_loss = tf.reduce_mean(tf.abs(self.x - self.x_recon))\n\n self.x_feature, self.D_real_x = self.discriminator(self.x)\n self.y_feature_1, self.D_real_y = self.discriminator(self.y_1)\n self.tilde_x_feature, self.D_fake = self.discriminator(self.tilde_x)\n self.x_feature_recon, self.D_fake_recon = self.discriminator(self.x_recon)\n\n self.feature_matching = 0.5 * getfeature_matching_loss(self.y_feature_1, self.tilde_x_feature) + \\\n 0.5 * getfeature_matching_loss(self.x_feature, self.x_feature_recon)\n\n self.D_gan_loss = self.loss_hinge_dis(self.D_real_y, self.D_fake, self.cls_y, self.cls_y)\n self.G_gan_loss = 0.5 * self.loss_hinge_gen(self.D_fake, self.cls_y) \\\n + 0.5 * self.loss_hinge_gen(self.D_fake_recon, self.cls_x)\n self.grad_penalty = self.gradient_penalty_just_real(x=self.y_1, label=self.cls_y)\n\n # weight decay\n self.l2_loss_d = getWeight_Decay(scope='discriminator')\n self.l2_loss_g = getWeight_Decay(scope='content_encoder') + getWeight_Decay(scope='class_encoder_k') + getWeight_Decay(scope='decoder')\n\n self.D_loss = self.D_gan_loss + self.opt.lam_gp * self.grad_penalty + self.l2_loss_d\n self.G_loss = self.G_gan_loss + self.opt.lam_recon * self.content_recon_loss + self.opt.lam_fp * self.feature_matching + self.l2_loss_g\n\n def train(self):\n\n log_vars = []\n log_vars.append(('D_loss', self.D_loss))\n log_vars.append(('G_loss', self.G_loss))\n\n vars = tf.trainable_variables()\n\n '''\n total_para = 0\n for variable in vars:\n shape = variable.get_shape()\n print(variable.name, shape)\n variable_para = 1\n for dim in shape:\n variable_para *= dim.value\n total_para += variable_para\n print(\"The total para\", total_para)\n '''\n\n g_vars = getTrainVariable(vars, scope='encoder') + getTrainVariable(vars, scope='decoder')\n d_vars = getTrainVariable(vars, scope='discriminator')\n\n assert len(vars) == len(g_vars) + len(d_vars)\n\n saver = tf.train.Saver()\n for k, v in log_vars:\n tf.summary.scalar(k, v)\n\n opti_G = tf.train.RMSPropOptimizer(self.opt.lr_g * self.lr_decay).minimize(loss=self.G_loss,\n var_list=g_vars)\n opti_D = tf.train.RMSPropOptimizer(self.opt.lr_g * self.lr_decay).minimize(loss=self.D_loss,\n var_list=d_vars)\n init = tf.global_variables_initializer()\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n\n with tf.Session(config=config) as sess:\n\n sess.run(init)\n summary_op = tf.summary.merge_all()\n summary_writer = tf.summary.FileWriter(self.opt.log_dir, sess.graph)\n\n ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)\n if ckpt and ckpt.model_checkpoint_path:\n start_step = int(ckpt.model_checkpoint_path.split('model_', 2)[1].split('.', 2)[0])\n saver.restore(sess, ckpt.model_checkpoint_path)\n print('Load Successfully!', ckpt.model_checkpoint_path)\n else:\n start_step = 0\n\n step = start_step\n lr_decay = 1\n\n print(\"Start reading dataset\")\n while step <= self.opt.niter:\n\n if step > self.opt.niter_decay and step % 2000 == 0:\n lr_decay = (self.opt.niter - step) / float(self.opt.niter - self.opt.iter_decay)\n\n source_image_x_data, target_image_y1_data, cls_x, cls_y = self.data_ob.getNextBatch()\n source_image_x = self.data_ob.getShapeForData(source_image_x_data)\n target_image_y1 = self.data_ob.getShapeForData(target_image_y1_data)\n\n f_d = {\n self.x :source_image_x, self.y_1:target_image_y1, self.cls_x: cls_x, self.cls_y: cls_y, self.lr_decay: lr_decay\n }\n\n sess.run(opti_D, feed_dict=f_d)\n sess.run(opti_G, feed_dict=f_d)\n\n summary_str = sess.run(summary_op, feed_dict=f_d)\n summary_writer.add_summary(summary_str, step)\n\n if step % self.opt.display_freq == 0:\n\n output_loss = sess.run([self.D_loss, self.D_gan_loss, self.G_loss, self.G_gan_loss,\n self.content_recon_loss, self.feature_matching, self.l2_loss_d, self.l2_loss_g], feed_dict=f_d)\n print(\"step %d, D_loss=%.4f, D_gan_loss=%.4f\"\n \" G_loss=%.4f, G_gan_loss=%.4f, content_recon=%.4f, feautre_loss=%.4f, l2_loss=%.4f, lr_decay=%.4f\" \n % (step, output_loss[0], output_loss[1], output_loss[2], output_loss[3],\n output_loss[4], output_loss[5], output_loss[6] + output_loss[7], lr_decay))\n\n if np.mod(step, self.opt.save_latest_freq) == 0:\n\n f_d = {\n self.x: source_image_x, self.y_1: target_image_y1}\n\n train_output_img = sess.run([\n self.x,\n self.y_1,\n self.tilde_x,\n self.x_recon\n ],feed_dict=f_d)\n\n output_img = np.concatenate([img for img in train_output_img[0:4]],axis=0)\n\n save_images(output_img, [output_img.shape[0]/self.opt.batchSize, self.opt.batchSize],\n '{}/{:02d}_output_img.jpg'.format(self.opt.sample_dir, step))\n\n if np.mod(step, self.opt.save_model_freq) == 0 and step != 0:\n saver.save(sess, os.path.join(self.opt.checkpoints_dir, 'model_{:06d}.ckpt'.format(step)))\n step += 1\n\n save_path = saver.save(sess, os.path.join(self.opt.checkpoints_dir, 'model_{:06d}.ckpt'.format(step)))\n summary_writer.close()\n\n print(\"Model saved in file: %s\" % save_path)\n\n def test(self):\n pass\n\n def reshape_tile(self, cls_l):\n return tf.tile(tf.reshape(tf.one_hot(cls_l, depth=self.opt.num_source_class),\n shape=[self.opt.batchSize, 1, 1, self.opt.num_source_class]), multiples=[1, 8, 8, 1])\n\n #conditional hinge loss\n def loss_hinge_dis(self, d_real_logits, d_fake_logits, cls_x, cls_y):\n cls_x = self.reshape_tile(cls_x)\n cls_y = self.reshape_tile(cls_y)\n loss = tf.reduce_mean(tf.nn.relu(tf.reduce_sum(cls_x * (1.0 - d_real_logits), axis=3)))\n loss += tf.reduce_mean(tf.nn.relu(tf.reduce_sum(cls_y * (1.0 + d_fake_logits), axis=3)))\n\n return loss\n\n def loss_hinge_gen(self, d_fake_logits, cls_x):\n cls_x = self.reshape_tile(cls_x)\n loss = - tf.reduce_mean(tf.reduce_sum(cls_x * d_fake_logits, axis=3))\n return loss\n\n def gradient_penalty_just_real(self, x, label):\n label = self.reshape_tile(label)\n _, discri_logits = self.discriminator(x)\n discri_logits = tf.squeeze(tf.reduce_sum(discri_logits * label, axis=3))\n gradients = tf.gradients(tf.reduce_mean(discri_logits), [x])[0]\n slopes = tf.reduce_sum(tf.square(gradients), reduction_indices=[1, 2, 3])\n return tf.reduce_mean(slopes)\n\n def content_encoder(self, x):\n\n necf_t = self.opt.necf_t\n n_g_ref_t = self.opt.n_g_ref_t\n with tf.variable_scope(\"content_encoder\", reuse=tf.AUTO_REUSE):\n\n x = conv2d(x, output_dim=necf_t, kernel=7, stride=1, padding='SAME', scope='conv-1')\n x = instance_norm(x,scope='IN-1', affine=False)\n x = tf.nn.relu(x)\n for i in range(self.opt.n_layers_ec):\n x = conv2d(x, output_dim=pow(2,i+1)* necf_t, kernel=4, stride=2, padding='SAME', scope='conv_{}'.format(i+1))\n x = instance_norm(x,scope='ins_{}'.format(i+1), affine=False)\n x = tf.nn.relu(x)\n\n for i in range(2):\n x = Resblock(x, channels=n_g_ref_t, is_start=False, is_norm=True, is_acti=True, affline=False, scope='residual_{}'.format(i))\n\n return x\n\n def class_encoder_k(self, y):\n\n nesf_t = self.opt.nesf_t\n with tf.variable_scope(\"class_encoder_k\", reuse=tf.AUTO_REUSE):\n y = tf.nn.relu(conv2d(y, output_dim=nesf_t, kernel=7, stride=1, padding='SAME',scope='conv-1'))\n for i in range(2):\n y = conv2d(y, output_dim=nesf_t * pow(2, i+1), kernel=4, stride=2, padding='SAME',scope='conv_{}'.format(i+1))\n y = tf.nn.relu(y)\n for i in range(self.opt.n_layers_es - 2):\n y = conv2d(y, output_dim=nesf_t * pow(2, 2), kernel=4, stride=2, padding='SAME',scope='conv_{}'.format(i+3))\n y = tf.nn.relu(y)\n y = Adaptive_pool2d(y, output_size=1)\n y = conv2d(y, output_dim=nesf_t, kernel=1, stride=1, padding='SAME')\n\n return tf.squeeze(y)\n\n def decoder(self, content_code, class_code):\n\n n_g_ref_t = self.opt.n_g_ref_t\n output_nc = self.opt.output_nc\n n_layers_de = self.opt.n_layers_de\n n_residual_de = self.opt.n_residual_de\n with tf.variable_scope(\"decoder\", reuse=tf.AUTO_REUSE):\n\n #MLP\n for i in range(3):\n if i == 2:\n class_code = fully_connect(input_=class_code, output_size=n_g_ref_t*8, scope='fc_{}'.format(i+1))\n else:\n class_code = tf.nn.relu(fully_connect(input_=class_code, output_size=n_g_ref_t // 2, scope='fc_{}'.format(i+1)))\n\n de = content_code\n\n for i in range(n_residual_de):\n mean1 = class_code[:,n_g_ref_t*i:n_g_ref_t*(i+1)]\n stand_dev1 = class_code[:,n_g_ref_t*(i+1):n_g_ref_t*(i+2)]\n mean2 = class_code[:,n_g_ref_t*(i+2):n_g_ref_t*(i+3)]\n stand_dev2 = class_code[:,n_g_ref_t*(i+3):n_g_ref_t*(i+4)]\n print(class_code)\n class_code = class_code[:,n_g_ref_t*(i+3):]\n\n de = Resblock_AdaIn(content_code, beta1=mean1, gamma1=stand_dev1, beta2=mean2, gamma2=stand_dev2,\n channels=n_g_ref_t, scope='res_{}'.format(i+1))\n\n n_g_ref_t = n_g_ref_t // 2\n for i in range(n_layers_de):\n de = upscale(de, scale=2)\n de = conv2d(de, output_dim=n_g_ref_t/pow(2,i), kernel=5, stride=1, padding='SAME', scope='conv_{}'.format(i+1))\n de = instance_norm(de, scope='ins_{}'.format(i+1), affine=False)\n de = tf.nn.relu(de)\n\n y = conv2d(de, output_dim=output_nc, kernel=7, stride=1, padding='SAME', scope='conv_final')\n\n return tf.nn.tanh(y)\n\n def discriminator(self, x):\n\n ndf = self.opt.ndf\n with tf.variable_scope(\"discriminator\", reuse=tf.AUTO_REUSE):\n\n x = lrelu(conv2d(input_=x, output_dim=ndf, kernel=7, stride=1, scope='conv-64'))\n for i in range(5):\n if i == 4:\n x = Resblock_D(x, channels=min(ndf * pow(2, i+1), 1024), is_acti=False, is_start=False, is_norm=False, scope='r1_{}'.format(i + 1))\n x = Resblock_D(x, channels=min(ndf * pow(2, i+1), 1024), is_acti=False, is_start=False, is_norm=False, scope='r2_{}'.format(i+1))\n else:\n x = Resblock_D(x, channels=min(ndf * pow(2, i+1), 1024), is_acti=True, is_start=True,\n is_norm=False,\n scope='r1_{}'.format(i + 1))\n x = Resblock_D(x, channels=min(ndf * pow(2, i+1), 1024), is_acti=True, is_start=False, is_norm=False, scope='r2_{}'.format(i+1))\n x = avgpool2d(x, k=2)\n\n x_predict = conv2d(lrelu(x), output_dim=self.opt.num_source_class, kernel=3, stride=1, padding='SAME')\n\n return x, tf.squeeze(x_predict)\n\n\n\n\n\n\n\n\n\n"
] |
[
[
"numpy.concatenate",
"numpy.mod"
]
] |
author9779/paper9779
|
[
"b544f60733794ff2dd344627f8ec0d87fe087266"
] |
[
"defaults/wrappers.py"
] |
[
"from .models import *\nfrom .datasets import *\nfrom utils._utils import *\n\nimport torch.distributed as dist\nfrom torch.nn.parallel import DistributedDataParallel as DDP\nfrom torch.utils.data.distributed import DistributedSampler as DS\n\nclass DefaultWrapper:\n \"\"\"Class that wraps everything.\n\n Model, optimizers, schedulers, and dataloaders are initialized in this class.\n\n Attributes:\n param_attributes:\n All the fields in the .json file are stored as attributes here.\n \"\"\"\n def __init__(self, parameters: edict):\n \"\"\"Inits the DefaultWrapper class.\n \n Args:\n parameters:\n Dictionary of paramaters read from a .json file.\n \"\"\"\n super().__init__()\n self.is_supervised = True\n parameters = edict(deepcopy(parameters))\n parameters = self.update_augmentation_strategy(parameters)\n self.param_attributes = list(parameters.keys())\n # adding effective batch size to optimizer_params\n batch_size = parameters.dataloader_params.trainloader.batch_size\n effective_batch_size = batch_size * self.visible_world\n for key in parameters.optimization_params.keys():\n parameters.optimization_params[key]['effective_batch_size'] = effective_batch_size \n autoscale_lr = parameters.optimization_params[key].optimizer.autoscale_lr\n if autoscale_lr:\n def_lr = parameters.optimization_params[key].optimizer.params.lr\n scaled_lr = def_lr * effective_batch_size / 256.\n parameters.optimization_params[key].optimizer.params.lr = scaled_lr \n for key in parameters:\n setattr(self, key, parameters[key]) \n \n def instantiate(self): \n \"\"\"Initialize model, loss, metrics, dataloaders, optimizer and scheduler.\"\"\"\n if self.is_rank0:\n print(\"Initialising Dataloaders . . .\")\n \n self.dataloaders = self.init_dataloaders()\n img_channels = self.dataloaders.trainloader.dataset.img_channels\n n_classes = self.dataloaders.trainloader.dataset.n_classes\n knn_nhood = self.dataloaders.trainloader.dataset.knn_nhood\n target_metric = self.dataloaders.trainloader.dataset.target_metric\n print_ddp(f\"The default metric has been set to : \\033[94m{target_metric}\\033[0m\")\n \n self.model_params.img_channels = img_channels\n self.model_params.knn_nhood = knn_nhood\n self.model_params.target_metric = target_metric\n \n # Checking for binary multi-label\n self.model_params.n_classes = n_classes\n is_multiclass = self.dataloaders.trainloader.dataset.is_multiclass\n if not is_multiclass and n_classes <= 2:\n print(\"\\033[93m Binary multi-label problem found: CHANING THE n_classes to 1\\033[0m\")\n self.model_params.n_classes = 1\n \n # adding WT checkpoint dir\n mname = self.training_params.model_name\n wt_name = self.model_params.backbone_type\n run_check = mname.split('-')[-1].split('_')\n if len(run_check) == 2 and run_check[0] == 'run':\n wt_name = f\"{wt_name}-run_{run_check[1]}\"\n wt_dir = os.path.join(self.training_params.save_dir, \"wt_inits\")\n self.model_params.wt_checkpoint = os.path.join(wt_dir, wt_name)\n \n # init and get model\n print_ddp(\"Initialising Model . . .\") \n self.model = self.init_model() \n \n print_ddp(\"Initialising Optimization methods . . \") \n # init and get optimizer\n optimizer_defs = self.init_optimizer(self.model, self.optimization_params.default) \n self.attr_from_dict(optimizer_defs)\n \n # init and get scheduler\n epochs = self.training_params.epochs\n scheduler_defs = self.init_scheduler(self.optimizer,\n self.optimization_params.default, \n len(self.dataloaders.trainloader), \n epochs) \n self.schedulers = MixedLRScheduler(**scheduler_defs)\n \n # init loss functions\n self.criterion = self.init_criteria() \n \n # init metric functions\n self.init_metrics()\n \n def init_dataloaders(self, collate_fn=None) -> edict:\n \"\"\"Define dataset params and dataloaders.\n \n Args:\n collate_fn:\n Specific collate_fn for the torch.utils.data.DataLoader.\n \n Returns:\n A dict (EasyDict) with train, validation and test loaders. nonddp_trainloader is\n for the 2nd phase of SWAP training where we don't use the distributed sampler.\n \n {'trainloader': trainloader,\n 'valloader': valloader,\n 'testloader': testloader,\n 'nonddp_trainloader':nonddp_trainloader}\n \"\"\" \n feature_bank_set, feature_bank_Loader = None, None\n DataSet = self.dataset_mapper.get(self.dataset_params.dataset, False)\n assert DataSet, \"Dataset not found - Plese select one of the following: {}\".format(list(self.dataset_mapper.keys()))\n\n trainset = DataSet(self.dataset_params, mode='train')\n valset = DataSet(self.dataset_params, mode='eval')\n testset = DataSet(self.dataset_params, mode='test')\n\n if self.training_params.knn_eval or not self.is_supervised:\n feature_bank_set = DataSet(self.dataset_params, mode='train')\n feature_bank_set.transform = valset.transform # Use validation transform when setting up prototype vectors\n feature_bank_set.resizing = valset.resizing \n \n if not self.is_supervised:\n trainset.num_augmentations = 2 \n \n #register task defs\n self.task = trainset.task\n self.is_multiclass = trainset.is_multiclass \n \n \n train_sampler = None\n feature_bank_sampler = None\n train_shuffle = self.dataloader_params['trainloader']['shuffle']\n # distributed sampler \n if ddp_is_on(): \n train_sampler = DS(trainset, num_replicas=self.visible_world, rank=self.device_id)\n if feature_bank_set is not None:\n feature_bank_sampler = DS(feature_bank_set, num_replicas=self.visible_world, shuffle=False,\n rank=self.device_id)\n self.dataloader_params['trainloader']['shuffle'] = False\n\n # define distributed samplers etc\n trainLoader = DataLoader(trainset, **self.dataloader_params['trainloader'],sampler=train_sampler)\n testLoader = DataLoader(testset, **self.dataloader_params['testloader'])\n if len(valset) > 0 :\n valLoader = DataLoader(valset, **self.dataloader_params['valloader'])\n else:\n valLoader = testLoader\n if feature_bank_set is not None:\n data_params_copy_feature_bank = deepcopy(self.dataloader_params['valloader'])\n data_params_copy_feature_bank['shuffle'] = False\n feature_bank_Loader = DataLoader(feature_bank_set,\n **data_params_copy_feature_bank ,sampler=feature_bank_sampler)\n self.dataloader_params['trainloader']['shuffle'] = train_shuffle\n\n if not len(valLoader):\n valLoader = testLoader \n if self.is_rank0:\n warnings.warn(\"Warning... Using test set as validation set\")\n\n return edict({'trainloader': trainLoader,\n 'valloader' : valLoader,\n 'testloader' : testLoader,\n 'fbank_loader' : feature_bank_Loader,\n })\n \n\n def init_model(self) -> Classifier:\n \"\"\"Initialize the model.\n \n DDP broadcasts model states from rank 0 process to all other processes \n in the DDP constructor, you don’t need to worry about different DDP processes \n start from different model parameter initial values. \n \"\"\"\n model = Classifier(self.model_params) \n model.to(self.device_id)\n if self.visible_world > 1 and torch.distributed.is_initialized():\n model = DDP(model, device_ids=[self.device_id])\n return model\n \n @staticmethod\n def init_optimizer(model, optimization_params:edict) -> edict: \n \"\"\"Initialize the optimizer.\n \n Args:\n optimization_params: EasyDict instance, read from the .json file.\n\n Returns:\n A dict (EasyDict) with optimizer and type keys.\n {'optimizer': optimizer (e.g. a torch.optim.Adam instance),\n 'optimizer_type': optimizer_type (e.g. a string \"Adam\")}\n \"\"\"\n optimizer_type = optimization_params.optimizer.type\n opt = optim.__dict__[optimizer_type]\n opt_params = optimization_params.optimizer.params\n optimizer = opt(DefaultWrapper.get_params_groups(model), **opt_params)\n\n # handling LARS\n lars_params = optimization_params.LARS_params\n effective_batch_size = optimization_params.effective_batch_size\n if lars_params.use and effective_batch_size >= lars_params.batch_act_thresh:\n print_ddp(\"LARS OPTIMIZER: \\033[92m ACTIVE \\033[0m\")\n optimizer = LARS(optimizer=optimizer, eps=lars_params.eps, trust_coef=lars_params.trust_coef)\n optimizer.defaults = optimizer.optim.defaults \n else:\n print_ddp(\"LARS OPTIMIZER: \\033[93m INACTIVE \\033[0m\")\n \n return edict({\"optimizer\":optimizer, \"optimizer_type\":optimizer_type})\n \n @staticmethod\n def get_params_groups(model):\n \"\"\"\n FROM: https://github.com/facebookresearch/dino/blob/main/utils.py\n It filters-out the no-grad params and it excludes weight_decay from all non-weight / non-bias tensors\n It will return 2 groups 0: regularized 1: not_regularized\n \"\"\"\n regularized = []\n not_regularized = []\n for name, param in model.named_parameters():\n if not param.requires_grad:\n continue\n # we do not regularize biases nor Norm parameters\n if name.endswith(\".bias\") or len(param.shape) == 1:\n not_regularized.append(param)\n else:\n regularized.append(param)\n return [{'params': regularized}, {'params': not_regularized, 'weight_decay': 0.}] \n \n @staticmethod \n def init_scheduler(optimizer, optimization_params: edict, steps_per_epoch: int=None, epochs: int=None) -> edict: \n \"\"\"Initialize the learning rate scheduler.\n\n steps_per_epoch and epochs are set by the caller, they are not intended to be None.\n \n Args:\n optimization_params: EasyDict instance, read from the .json file.\n \n Returns:\n A dict (EasyDict) with scheduler and type keys.\n {'scheduler': scheduler (e.g. a torch.optim.lr_scheduler.OneCycleLR instance),\n 'scheduler_type': scheduler_type (e.g. a string \"OneCycleLR\")}\n \"\"\"\n schedulers = edict({\"schedulers\":[None], \"scheduler_types\":[None], \n \"steps_per_epoch\":steps_per_epoch})\n scheduler_types = optimization_params.scheduler.type\n accepted_types = [None, \"LinearWarmup\", \"MultiStepLR\", \n \"ReduceLROnPlateau\", \"OneCycleLR\", \"CosineAnnealingLR\"] \n if not isinstance(scheduler_types, list):\n scheduler_types = [scheduler_types] \n \n for scheduler_type in scheduler_types:\n if scheduler_type not in accepted_types:\n raise ValueError(f\"{scheduler_type} is not a supported scheduler\")\n \n if scheduler_type is None:\n continue\n elif scheduler_type not in optim.lr_scheduler.__dict__:\n if scheduler_type == 'LinearWarmup':\n sch = LinearWarmup \n else:\n raise NotImplementedError\n else:\n sch = optim.lr_scheduler.__dict__[scheduler_type]\n\n if sch.__name__ == 'OneCycleLR':\n max_lr = optimization_params.optimizer.params.lr\n sch_params = {\"max_lr\":max_lr, \n \"steps_per_epoch\":steps_per_epoch, \n \"epochs\":epochs,\n \"div_factor\": max_lr/1e-8\n }\n if \"LinearWarmup\" in scheduler_types:\n sch_params[\"div_factor\"] = 1.\n sch_params.update(optimization_params.scheduler.params.OneCycleLR)\n elif sch.__name__ == 'LinearWarmup':\n max_lr = optimization_params.optimizer.params.lr\n sch_params = optimization_params.scheduler.params[scheduler_type]\n sch_params.update({\"max_lr\":max_lr, \"steps_per_epoch\":steps_per_epoch})\n elif sch.__name__ == 'CosineAnnealingLR':\n T_max = steps_per_epoch * epochs\n sch_params = optimization_params.scheduler.params[scheduler_type]\n if \"LinearWarmup\" in scheduler_types:\n T_max = T_max - warmup_iters\n sch_params.update({\"T_max\":T_max})\n else:\n sch_params = optimization_params.scheduler.params[scheduler_type]\n \n scheduler = sch(optimizer, **sch_params) \n schedulers[\"schedulers\"].append(scheduler)\n schedulers[\"scheduler_types\"].append(scheduler_type)\n \n if scheduler_type == 'LinearWarmup':\n warmup_iters = scheduler.warmup_iters\n\n return schedulers\n \n def init_criteria(self): \n \"\"\"Initialize the loss criteria. \"\"\"\n if self.task == 'classification':\n if self.is_multiclass:\n crit = nn.CrossEntropyLoss() \n else:\n crit = nn.BCEWithLogitsLoss() \n else:\n raise NotImplementedError(\"Only classification tasks are implemented for now\")\n \n return crit\n \n def init_metrics(self):\n if self.task == 'classification':\n if self.is_multiclass:\n self.metric = DefaultClassificationMetrics \n else:\n self.metric = MultiLabelClassificationMetrics\n else:\n raise NotImplementedError(\"Only classification tasks are implemented for now\") \n \n def attr_from_dict(self, param_dict: edict):\n \"\"\"Function that makes the dictionary key-values into attributes.\n \n This allows us to use the dot syntax. Check the .json file for the entries.\n\n Args:\n param_dict: The dict we populate the class attributes from.\n \"\"\"\n self.name = self.__class__.__name__\n for key in param_dict:\n setattr(self, key, param_dict[key]) \n \n def update_augmentation_strategy(self, parameters):\n self_dir = os.path.dirname(os.path.abspath(inspect.getfile(self.__class__)))\n new_strategy_dir = os.path.join(self_dir, \"augmentation_strategy.json\") \n if not os.path.isfile(new_strategy_dir):\n return parameters\n \n augmentation_strategy = edict(load_json(new_strategy_dir))\n general_args = augmentation_strategy.general_args\n repetition_strategy = augmentation_strategy.repetition_strategy\n transforms = augmentation_strategy.transforms\n to_change = list(transforms.keys())\n \n if not general_args.overwrite_defaults:\n return parameters\n params = deepcopy(parameters)\n \n for org_keys in parameters.dataset_params.keys():\n if org_keys in to_change:\n org_def = parameters.dataset_params[org_keys]\n updated_transforms = []\n for order, aug_type in enumerate(repetition_strategy.order):\n new_trans = transforms[org_keys][aug_type]\n n_augs = repetition_strategy.n_augmentations[order]\n if general_args.inherit:\n for key in general_args.inherit:\n new_trans[key] = org_def[key] \n for _ in range(n_augs):\n updated_transforms.append(new_trans)\n params.dataset_params[org_keys] = updated_transforms \n \n return params \n \n @property\n def parameters(self):\n return edict({key : getattr(self, key) \n for key in self.param_attributes})\n \n @property\n def dataset_mapper(self):\n return {\n \"CheXpert\" : CheXpert,\n \"DDSM\" : DDSM,\n \"ISIC2019\": ISIC2019,\n \"APTOS2019\": APTOS2019,\n \"Camelyon\": Camelyon,\n }\n \n @property\n def visible_world(self):\n return torch.cuda.device_count() \n \n @property\n def visible_ids(sefl):\n return list(range(torch.cuda.device_count()))\n \n @property\n def device_id(self): \n return torch.cuda.current_device() if self.visible_world else \"cpu\"\n \n @property\n def is_rank0(self):\n return is_rank0(self.device_id)\n"
] |
[
[
"torch.nn.parallel.DistributedDataParallel",
"torch.utils.data.distributed.DistributedSampler"
]
] |
jeford/mdprop
|
[
"e79b70343f559cbf586f09234122c2f43b4d867c",
"e79b70343f559cbf586f09234122c2f43b4d867c",
"e79b70343f559cbf586f09234122c2f43b4d867c"
] |
[
"examples/kepler/kepler_exp_timestep.py",
"examples/prinz/timestep_map.py",
"examples/joukowsky/joukowsky.py"
] |
[
"#!/usr/bin/env python\nimport numpy as np\n\nimport mdprop\n\nimport matplotlib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pyplot as plt\n\npot = mdprop.potential.Kepler(1.0)\nmasses = np.array([1.0])\nX, V = pot.init_cond(0.8)\nsymbols = ['X']\n\nstate = {\n 'X': X,\n 'V': V,\n 'symbols': symbols,\n 'masses': masses,\n 'potential_energy': pot.compute_energy(X)\n}\n\n# Set up parameters for dynamics\nbeta = 0.25\ndt = 0.005\nsim_time = 10.0\n\n# Construct update objects using pointers to different forces\nvel_update = mdprop.update.VelocityUpdate(pot.compute_forces)\n\n# Construct integrator\ninteg = mdprop.integrator.VelocityVerlet(vel_update)\nprint(integ)\n\n# Save energy, times to h5\nh5hook = mdprop.hook.WriteH5(\"exp.h5\", ['kinetic_energy', 'total_energy', 'simulation_time'], [(1, ), (1, ), (1, )], ['f', 'f', 'f'], cache_size=1)\n\ntraj = mdprop.trajectory.Trajectory(integ)\nts_control = mdprop.hook.TimestepController(mdprop.control.exponential, beta)\ntraj.append_hooks([mdprop.hook.Gradient(vel_update), ts_control])\ntraj.append_hook(h5hook)\ntraj.append_printkeys(['dt', 'control'])\ntraj.run(dt, sim_time, state)\n\nKE = h5hook.h5file['kinetic_energy'][...]\nTE = h5hook.h5file['total_energy'][...]\nTs = h5hook.h5file['simulation_time'][...]\ndts = Ts[1:] - Ts[:-1]\nprint(len(dts))\n\nfig, ax1 = plt.subplots()\nax1.plot(Ts, TE, color='tab:blue', ls='-', label='Total energy')\nax2 = ax1.twinx()\nax2.plot(Ts[1:], dts, color='tab:red', ls='--')\nax1.set_ylim([-0.5001, -0.497])\nax1.set_xlabel('Simulation Time')\nax1.set_ylabel(\"Total Energy\", color='tab:blue')\nax2.set_ylabel(\"Time step\", color='tab:red')\nplt.title(\"Total Energy vs. Time\")\nplt.tight_layout()\nplt.savefig(\"exp_total.eps\")\n\nfig, ax1 = plt.subplots()\nax1.plot(Ts, KE, color='tab:blue', ls='-', label='Kinetic energy')\nax2 = ax1.twinx()\nax2.plot(Ts[1:], dts, color='tab:red', ls='--')\nax1.set_xlabel('Simulation Time')\nax1.set_ylabel(\"Kinetic Energy\", color='tab:blue')\nax2.set_ylabel(\"Time step\", color='tab:red')\nplt.title(\"Kinetic Energy vs. Time\")\nplt.tight_layout()\nplt.savefig(\"exp_kinetic.eps\")\n",
"import numpy as np\n\nimport matplotlib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pyplot as plt\n\nimport mdprop\n\npot = mdprop.potential.Prinz()\nX = np.array([[-1.0]])\nV = np.array([[ 0.0]])\nmasses = np.array([1.0])\nsymbols = ['X']\nbeta = 0.1\ndt = 0.01\nsim_time = 10.0\n\nstate = {\n 'X': X,\n 'V': V,\n 'masses': masses,\n 'symbols': symbols,\n 'potential_energy': pot.compute_energy(X),\n }\n\nvup = mdprop.update.VelocityUpdate(pot.compute_force)\n\ninteg = mdprop.integrator.VelocityVerlet(vup)\n\ntraj = mdprop.trajectory.Trajectory(integ)\n\ngradhook = mdprop.hook.Gradient(vup)\ntschook = mdprop.hook.TimestepController(mdprop.control.exponential, beta)\nh5hook = mdprop.hook.WriteH5(\"prinz.h5\", [\"X\", \"potential_energy\", \"total_energy\", \"simulation_time\"], [(1, 1), (1, ), (1, ), (1, )], ['f', 'f', 'f', 'f'], cache_size=1)\ntraj.append_hooks([gradhook, h5hook, tschook])\ntraj.append_printkey('dt')\ntraj.run(dt, sim_time, state)\n\nh5file = h5hook.h5file\nXs = h5file['X'][:, 0, 0]\nTs = h5file['simulation_time'][:, 0]\nPEs = h5file['potential_energy'][:, 0]\nTEs = h5file['total_energy'][:, 0]\ndts = Ts[1:] - Ts[:-1]\ndts_scaled = (dts - min(dts))/max(dts - min(dts)) * 4.0\n#dts_scaled = dts / min(dts) * 2.0\n\nplt.figure()\nplt.plot(Xs, PEs)\nplt.plot(Xs[1:], dts_scaled)\nplt.savefig(\"prinz.eps\")\n\nplt.figure()\nplt.plot(Ts, TEs)\nplt.savefig(\"energy.eps\")\n",
"import numpy as np\n\nimport matplotlib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pyplot as plt\n\nimport mdprop\n\nclass Joukowsky(mdprop.potential.Potential):\n def __init__(self, alpha=1.0):\n self.alpha = alpha\n\n def compute_energy_per_particle(self, X, **state):\n r = np.linalg.norm(X, axis=1)\n return self.alpha * r + 1.0/r\n\n def compute_energy(self, X, **state):\n return np.sum(self.compute_energy_per_particle(X, **state))\n\n def compute_gradient(self, X, **state):\n r = np.linalg.norm(X, axis=1)[:, None]\n V = np.sum(self.alpha * r + 1.0 / r)\n G = self.alpha * X / r - X / (r ** 3)\n return V, G\n\n# Params\ndt = 0.05\nsim_time = 13.0\nbeta = 0.2\n\nx = np.linspace(0.1, 2.0, 100)[:, None]\npot = Joukowsky(5.0)\ny = pot.compute_energy_per_particle(x)\n_, g = pot.compute_gradient(x)\nng = mdprop.utils.numerical_gradient(x, pot.compute_energy)\nprint(max(g - ng))\n\nvup = mdprop.update.VelocityUpdate(pot.compute_force)\ninteg = mdprop.integrator.VelocityVerlet(vup)\n\nX = np.array([[-2.0]])\nV = np.array([[0.0]])\nmasses = np.array([1.0])\nsymbols = ['X']\ninit_pot = pot.compute_energy(X)\n\ninit_state = {\n 'X': X,\n 'V': V,\n 'masses': masses,\n 'symbols': symbols,\n 'potential_energy': init_pot,\n }\n\nstate = init_state.copy()\ntraj = mdprop.trajectory.Trajectory(integ)\nh5hook = mdprop.hook.WriteH5('joukowsky.h5', ['X', 'total_energy'], [(1, 1), (1, )], ['f', 'f'], cache_size=1)\ntraj.append_hook(h5hook)\ntraj.run(dt, sim_time, state)\n\nxs = h5hook.h5file['X'][:, :, 0]\nes = h5hook.h5file['total_energy'][:, 0]\nvs = pot.compute_energy_per_particle(xs)\n\nstate = init_state.copy()\ntraj = mdprop.trajectory.Trajectory(integ)\ngradhook = mdprop.hook.Gradient(vup)\nh5hook_vts = mdprop.hook.WriteH5('joukowsky_vts.h5', ['X', 'total_energy'], [(1, 1), (1, )], ['f', 'f'], cache_size=1)\ntshook = mdprop.hook.TimestepController(mdprop.control.exponential, beta)\ntraj.append_hooks([gradhook, h5hook_vts, tshook])\ntraj.run(dt, sim_time, state)\n\nxs_vts = h5hook_vts.h5file['X'][:, :, 0]\nes_vts = h5hook_vts.h5file['total_energy'][:, 0]\nvs_vts = pot.compute_energy_per_particle(xs_vts)\n\nprint(len(xs))\nprint(len(xs_vts))\n\n# Plot the VV trajectory\nxmin = np.min(xs)\nxmax = np.max(xs)\nx = np.linspace(xmin, xmax, 100)[:, None]\ny = pot.compute_energy_per_particle(x)\n\nplt.figure()\nplt.plot(x, y)\nplt.plot(xs, vs, marker='o', ls='', label='Potential')\nplt.plot(xs, es, marker='o', color='g', label='Total')\nplt.xlabel(\"X\")\nplt.ylabel(\"Energy\")\nplt.legend()\nplt.tight_layout()\nplt.savefig(\"joukowsky.eps\")\n\n# Plot the VV VTS trajectory\nxmin_vts = np.min(xs_vts)\nxmax_vts = np.max(xs_vts)\nx_vts = np.linspace(xmin_vts, xmax_vts, 100)[:, None]\ny_vts = pot.compute_energy_per_particle(x_vts)\n\nplt.figure()\nplt.plot(x_vts, y_vts)\nplt.plot(xs_vts, vs_vts, marker='o', ls='', label='Potential')\nplt.plot(xs_vts, es_vts, marker='o', color='g', label='Total')\nplt.xlabel(\"X\")\nplt.ylabel(\"Energy\")\nplt.legend()\nplt.tight_layout()\nplt.savefig(\"joukowsky_vts.eps\")\n"
] |
[
[
"matplotlib.use",
"numpy.array",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.tight_layout"
],
[
"matplotlib.use",
"numpy.array",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.figure"
],
[
"matplotlib.use",
"numpy.max",
"numpy.array",
"numpy.linalg.norm",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"numpy.min",
"numpy.sum",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.ylabel",
"numpy.linspace"
]
] |
VictorAtPL/Speech_Commands_Recognition_Bi_LSTM_with_Tensorflow_2
|
[
"d8ed6052baa8289c9856ee3582979c6203f94009"
] |
[
"models/baseline_bilstm_bigger_2_dense_bigger.py"
] |
[
"import tensorflow as tf\n\nfrom AbstractModel import AbstractModel\nfrom common import get_input_fn_and_steps_per_epoch, load_sets_count, mel_spectrogram_unlabeled_parser\nfrom constants import TFRECORDS_SAVE_PATH\n\nfrom models.baseline import Model as Baseline\n\n\nclass Model(Baseline):\n\n def get_model(self):\n input_op = tf.keras.Input(shape=(128, 44))\n\n dropout = 0.0\n layers = tf.keras.layers\n # BATCH_NORM\n x = layers.BatchNormalization()(input_op)\n\n # LSTM\n # https://github.com/tensorflow/tensorflow/issues/30263\n x = layers.Bidirectional(layers.LSTM(256, activation='sigmoid', return_sequences=True))(x)\n x = layers.Dropout(dropout)(x)\n\n # LSTM\n # https://github.com/tensorflow/tensorflow/issues/30263\n x = layers.Bidirectional(layers.LSTM(256, activation='sigmoid', return_sequences=True))(x)\n x = layers.Dropout(dropout)(x)\n\n # LSTM\n # https://github.com/tensorflow/tensorflow/issues/30263\n x = layers.Bidirectional(layers.LSTM(256, activation='sigmoid'))(x)\n x = layers.Dropout(dropout)(x)\n\n # BATCH_NORM\n x = layers.BatchNormalization()(x)\n\n # DENSE\n x = layers.Dense(512)(x)\n x = layers.BatchNormalization()(x)\n x = layers.Activation('relu')(x)\n x = layers.Dropout(dropout)(x)\n\n # DENSE\n x = layers.Dense(256)(x)\n x = layers.BatchNormalization()(x)\n x = layers.Activation('relu')(x)\n x = layers.Dropout(dropout)(x)\n\n # DENSE\n x = layers.Dense(128)(x)\n x = layers.BatchNormalization()(x)\n x = layers.Activation('relu')(x)\n x = layers.Dropout(dropout)(x)\n\n # DENSE\n x = layers.Dense(64)(x)\n x = layers.BatchNormalization()(x)\n x = layers.Activation('relu')(x)\n x = layers.Dropout(dropout)(x)\n\n output_op = layers.Dense(12)(x)\n\n return tf.keras.Model(inputs=input_op, outputs=output_op)\n"
] |
[
[
"tensorflow.keras.Input",
"tensorflow.keras.Model"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.