repo_name
stringlengths 8
130
| hexsha
sequence | file_path
sequence | code
sequence | apis
sequence |
|---|---|---|---|---|
riels89/gunpowder | [
"e523b49ca846a9fd46ab6fc0dd1040cc4a4d53b4"
] | [
"tests/cases/specified_location.py"
] | [
"# from .provider_test import ProviderTest, TestSource\nfrom gunpowder import (BatchProvider, ArrayKeys, ArraySpec, Roi, Batch,\n Coordinate, SpecifiedLocation, build,\n BatchRequest, Array, ArrayKey)\nimport numpy as np\nimport unittest\n\n\nclass TestSourceSpecifiedLocation(BatchProvider):\n def __init__(self, roi, voxel_size):\n self.voxel_size = Coordinate(voxel_size)\n self.roi = roi\n size = self.roi.get_shape() / self.voxel_size\n self.data = np.arange(np.prod(size)).reshape(size)\n\n def setup(self):\n self.provides(\n ArrayKeys.RAW,\n ArraySpec(\n roi=self.roi,\n voxel_size=self.voxel_size))\n\n def provide(self, request):\n batch = Batch()\n\n spec = request[ArrayKeys.RAW].copy()\n spec.voxel_size = self.voxel_size\n size = spec.roi.get_shape() / spec.voxel_size\n offset = spec.roi.get_offset() / spec.voxel_size\n slce = tuple(slice(o, o + s) for o, s in zip(offset, size))\n\n batch.arrays[ArrayKeys.RAW] = Array(\n data=self.data[slce],\n spec=spec)\n\n return batch\n\n\nclass TestSpecifiedLocation(unittest.TestCase):\n\n def setUp(self):\n ArrayKey('RAW')\n\n def test_simple(self):\n\n locations = [\n [0, 0, 0],\n [100, 100, 100],\n [91, 20, 20],\n [42, 24, 57]\n ]\n\n pipeline = (\n TestSourceSpecifiedLocation(\n roi=Roi((0, 0, 0), (100, 100, 100)),\n voxel_size=(1, 1, 1)) +\n SpecifiedLocation(\n locations,\n choose_randomly=False,\n extra_data=None,\n jitter=None)\n )\n\n with build(pipeline):\n\n batch = pipeline.request_batch(\n BatchRequest(\n {\n ArrayKeys.RAW: ArraySpec(\n roi=Roi((0, 0, 0), (20, 20, 20)))\n }))\n # first three locations are skipped\n # fourth should start at [32, 14, 47] of self.data\n self.assertEqual(batch.arrays[ArrayKeys.RAW].data[0, 0, 0], 321447)\n\n def test_voxel_size(self):\n\n locations = [\n [0, 0, 0],\n [91, 20, 20],\n [42, 24, 57]\n ]\n\n pipeline = (\n TestSourceSpecifiedLocation(\n roi=Roi((0, 0, 0), (100, 100, 100)),\n voxel_size=(5, 2, 2)) +\n SpecifiedLocation(\n locations,\n choose_randomly=False,\n extra_data=None,\n jitter=None)\n )\n\n with build(pipeline):\n\n batch = pipeline.request_batch(\n BatchRequest(\n {\n ArrayKeys.RAW: ArraySpec(\n roi=Roi((0, 0, 0), (20, 20, 20)))\n }))\n # first locations is skipped\n # second should start at [80/5, 10/2, 10/2] = [16, 5, 5]\n self.assertEqual(batch.arrays[ArrayKeys.RAW].data[0, 0, 0], 40255)\n\n batch = pipeline.request_batch(\n BatchRequest(\n {\n ArrayKeys.RAW: ArraySpec(\n roi=Roi((0, 0, 0), (20, 20, 20)))\n }))\n # third should start at [30/5, 14/2, 48/2] = [6, 7, 23]\n self.assertEqual(batch.arrays[ArrayKeys.RAW].data[0, 0, 0], 15374)\n\n def test_jitter_and_random(self):\n\n locations = [\n [0, 0, 0],\n [91, 20, 20],\n [42, 24, 57]\n ]\n\n pipeline = (\n TestSourceSpecifiedLocation(\n roi=Roi((0, 0, 0), (100, 100, 100)),\n voxel_size=(5, 2, 2)) +\n SpecifiedLocation(\n locations,\n choose_randomly=True,\n extra_data=None,\n jitter=(5, 5, 5))\n )\n\n with build(pipeline):\n\n batch = pipeline.request_batch(\n BatchRequest(\n {\n ArrayKeys.RAW: ArraySpec(\n roi=Roi((0, 0, 0), (20, 20, 20)))\n }))\n # Unclear what result should be, so no errors means passing\n self.assertTrue(batch.arrays[ArrayKeys.RAW].data[0, 0, 0] > 0)\n"
] | [
[
"numpy.prod"
]
] |
joshes/ocp | [
"e04056d008616eaf5058b7851d8ac29b8f2da473"
] | [
"ocpmodels/trainers/forces_trainer.py"
] | [
"\"\"\"\nCopyright (c) Facebook, Inc. and its affiliates.\n\nThis source code is licensed under the MIT license found in the\nLICENSE file in the root directory of this source tree.\n\"\"\"\n\nimport os\nfrom collections import defaultdict\n\nimport numpy as np\nimport torch\nimport torch_geometric\nfrom torch.utils.data import DataLoader, DistributedSampler\nfrom tqdm import tqdm\n\nfrom ocpmodels.common import distutils\nfrom ocpmodels.common.data_parallel import ParallelCollater\nfrom ocpmodels.common.registry import registry\nfrom ocpmodels.common.relaxation.ml_relaxation import ml_relax\nfrom ocpmodels.common.utils import plot_histogram\nfrom ocpmodels.modules.evaluator import Evaluator\nfrom ocpmodels.modules.normalizer import Normalizer\nfrom ocpmodels.trainers.base_trainer import BaseTrainer\n\n\[email protected]_trainer(\"forces\")\nclass ForcesTrainer(BaseTrainer):\n \"\"\"\n Trainer class for the Structure to Energy & Force (S2EF) and Initial State to\n Relaxed State (IS2RS) tasks.\n\n .. note::\n\n Examples of configurations for task, model, dataset and optimizer\n can be found in `configs/ocp_s2ef <https://github.com/Open-Catalyst-Project/baselines/tree/master/configs/ocp_is2re/>`_\n and `configs/ocp_is2rs <https://github.com/Open-Catalyst-Project/baselines/tree/master/configs/ocp_is2rs/>`_.\n\n Args:\n task (dict): Task configuration.\n model (dict): Model configuration.\n dataset (dict): Dataset configuration. The dataset needs to be a SinglePointLMDB dataset.\n optimizer (dict): Optimizer configuration.\n identifier (str): Experiment identifier that is appended to log directory.\n run_dir (str, optional): Path to the run directory where logs are to be saved.\n (default: :obj:`None`)\n is_debug (bool, optional): Run in debug mode.\n (default: :obj:`False`)\n is_vis (bool, optional): Run in debug mode.\n (default: :obj:`False`)\n print_every (int, optional): Frequency of printing logs.\n (default: :obj:`100`)\n seed (int, optional): Random number seed.\n (default: :obj:`None`)\n logger (str, optional): Type of logger to be used.\n (default: :obj:`tensorboard`)\n local_rank (int, optional): Local rank of the process, only applicable for distributed training.\n (default: :obj:`0`)\n amp (bool, optional): Run using automatic mixed precision.\n (default: :obj:`False`)\n \"\"\"\n\n def __init__(\n self,\n task,\n model,\n dataset,\n optimizer,\n identifier,\n run_dir=None,\n is_debug=False,\n is_vis=False,\n print_every=100,\n seed=None,\n logger=\"tensorboard\",\n local_rank=0,\n amp=False,\n ):\n super().__init__(\n task=task,\n model=model,\n dataset=dataset,\n optimizer=optimizer,\n identifier=identifier,\n run_dir=run_dir,\n is_debug=is_debug,\n is_vis=is_vis,\n print_every=print_every,\n seed=seed,\n logger=logger,\n local_rank=local_rank,\n amp=amp,\n name=\"s2ef\",\n )\n\n def load_task(self):\n print(\"### Loading dataset: {}\".format(self.config[\"task\"][\"dataset\"]))\n\n self.parallel_collater = ParallelCollater(\n 1, self.config[\"model_attributes\"].get(\"otf_graph\", False)\n )\n if self.config[\"task\"][\"dataset\"] == \"trajectory_lmdb\":\n self.train_dataset = registry.get_dataset_class(\n self.config[\"task\"][\"dataset\"]\n )(self.config[\"dataset\"])\n\n self.train_loader = DataLoader(\n self.train_dataset,\n batch_size=self.config[\"optim\"][\"batch_size\"],\n shuffle=True,\n collate_fn=self.parallel_collater,\n num_workers=self.config[\"optim\"][\"num_workers\"],\n pin_memory=True,\n )\n\n self.val_loader = self.test_loader = None\n\n if \"val_dataset\" in self.config:\n self.val_dataset = registry.get_dataset_class(\n self.config[\"task\"][\"dataset\"]\n )(self.config[\"val_dataset\"])\n self.val_loader = DataLoader(\n self.val_dataset,\n self.config[\"optim\"].get(\"eval_batch_size\", 64),\n shuffle=False,\n collate_fn=self.parallel_collater,\n num_workers=self.config[\"optim\"][\"num_workers\"],\n pin_memory=True,\n )\n if \"test_dataset\" in self.config:\n self.test_dataset = registry.get_dataset_class(\n self.config[\"task\"][\"dataset\"]\n )(self.config[\"test_dataset\"])\n self.test_loader = DataLoader(\n self.test_dataset,\n self.config[\"optim\"].get(\"eval_batch_size\", 64),\n shuffle=False,\n collate_fn=self.parallel_collater,\n num_workers=self.config[\"optim\"][\"num_workers\"],\n pin_memory=True,\n )\n\n if \"relax_dataset\" in self.config[\"task\"]:\n assert os.path.isfile(\n self.config[\"task\"][\"relax_dataset\"][\"src\"]\n )\n\n self.relax_dataset = registry.get_dataset_class(\n \"single_point_lmdb\"\n )(self.config[\"task\"][\"relax_dataset\"])\n\n self.relax_sampler = DistributedSampler(\n self.relax_dataset,\n num_replicas=distutils.get_world_size(),\n rank=distutils.get_rank(),\n shuffle=False,\n )\n self.relax_loader = DataLoader(\n self.relax_dataset,\n batch_size=self.config[\"optim\"].get(\"eval_batch_size\", 64),\n collate_fn=self.parallel_collater,\n num_workers=self.config[\"optim\"][\"num_workers\"],\n pin_memory=True,\n sampler=self.relax_sampler,\n )\n\n else:\n self.dataset = registry.get_dataset_class(\n self.config[\"task\"][\"dataset\"]\n )(self.config[\"dataset\"])\n (\n self.train_loader,\n self.val_loader,\n self.test_loader,\n ) = self.dataset.get_dataloaders(\n batch_size=self.config[\"optim\"][\"batch_size\"],\n collate_fn=self.parallel_collater,\n )\n\n self.num_targets = 1\n\n # Normalizer for the dataset.\n # Compute mean, std of training set labels.\n self.normalizers = {}\n if self.config[\"dataset\"].get(\"normalize_labels\", False):\n if \"target_mean\" in self.config[\"dataset\"]:\n self.normalizers[\"target\"] = Normalizer(\n mean=self.config[\"dataset\"][\"target_mean\"],\n std=self.config[\"dataset\"][\"target_std\"],\n device=self.device,\n )\n else:\n self.normalizers[\"target\"] = Normalizer(\n tensor=self.train_loader.dataset.data.y[\n self.train_loader.dataset.__indices__\n ],\n device=self.device,\n )\n\n # If we're computing gradients wrt input, set mean of normalizer to 0 --\n # since it is lost when compute dy / dx -- and std to forward target std\n if self.config[\"model_attributes\"].get(\"regress_forces\", True):\n if self.config[\"dataset\"].get(\"normalize_labels\", False):\n if \"grad_target_mean\" in self.config[\"dataset\"]:\n self.normalizers[\"grad_target\"] = Normalizer(\n mean=self.config[\"dataset\"][\"grad_target_mean\"],\n std=self.config[\"dataset\"][\"grad_target_std\"],\n device=self.device,\n )\n else:\n self.normalizers[\"grad_target\"] = Normalizer(\n tensor=self.train_loader.dataset.data.y[\n self.train_loader.dataset.__indices__\n ],\n device=self.device,\n )\n self.normalizers[\"grad_target\"].mean.fill_(0)\n\n if (\n self.is_vis\n and self.config[\"task\"][\"dataset\"] != \"qm9\"\n and distutils.is_master()\n ):\n # Plot label distribution.\n plots = [\n plot_histogram(\n self.train_loader.dataset.data.y.tolist(),\n xlabel=\"{}/raw\".format(self.config[\"task\"][\"labels\"][0]),\n ylabel=\"# Examples\",\n title=\"Split: train\",\n ),\n plot_histogram(\n self.val_loader.dataset.data.y.tolist(),\n xlabel=\"{}/raw\".format(self.config[\"task\"][\"labels\"][0]),\n ylabel=\"# Examples\",\n title=\"Split: val\",\n ),\n plot_histogram(\n self.test_loader.dataset.data.y.tolist(),\n xlabel=\"{}/raw\".format(self.config[\"task\"][\"labels\"][0]),\n ylabel=\"# Examples\",\n title=\"Split: test\",\n ),\n ]\n self.logger.log_plots(plots)\n\n # Takes in a new data source and generates predictions on it.\n def predict(\n self, data_loader, per_image=True, results_file=None, disable_tqdm=True\n ):\n if distutils.is_master() and not disable_tqdm:\n print(\"### Predicting on test.\")\n assert isinstance(\n data_loader,\n (\n torch.utils.data.dataloader.DataLoader,\n torch_geometric.data.Batch,\n ),\n )\n rank = distutils.get_rank()\n\n if isinstance(data_loader, torch_geometric.data.Batch):\n data_loader = [[data_loader]]\n\n self.model.eval()\n if self.normalizers is not None and \"target\" in self.normalizers:\n self.normalizers[\"target\"].to(self.device)\n self.normalizers[\"grad_target\"].to(self.device)\n\n predictions = {\"id\": [], \"energy\": [], \"forces\": []}\n\n for i, batch_list in tqdm(\n enumerate(data_loader),\n total=len(data_loader),\n position=rank,\n desc=\"device {}\".format(rank),\n disable=disable_tqdm,\n ):\n with torch.cuda.amp.autocast(enabled=self.scaler is not None):\n out = self._forward(batch_list)\n\n if self.normalizers is not None and \"target\" in self.normalizers:\n out[\"energy\"] = self.normalizers[\"target\"].denorm(\n out[\"energy\"]\n )\n out[\"forces\"] = self.normalizers[\"grad_target\"].denorm(\n out[\"forces\"]\n )\n if per_image:\n atoms_sum = 0\n systemids = [\n str(i) + \"_\" + str(j)\n for i, j in zip(\n batch_list[0].sid.tolist(), batch_list[0].fid.tolist()\n )\n ]\n predictions[\"id\"].extend(systemids)\n predictions[\"energy\"].extend(\n out[\"energy\"].to(torch.float16).tolist()\n )\n batch_natoms = torch.cat(\n [batch.natoms for batch in batch_list]\n )\n batch_fixed = torch.cat([batch.fixed for batch in batch_list])\n for natoms in batch_natoms:\n forces = (\n out[\"forces\"][atoms_sum : natoms + atoms_sum]\n .cpu()\n .detach()\n .to(torch.float16)\n .numpy()\n )\n # evalAI only requires forces on free atoms\n if results_file is not None:\n _free_atoms = (\n batch_fixed[atoms_sum : natoms + atoms_sum] == 0\n ).tolist()\n forces = forces[_free_atoms]\n atoms_sum += natoms\n predictions[\"forces\"].append(forces)\n else:\n predictions[\"energy\"] = out[\"energy\"].detach()\n predictions[\"forces\"] = out[\"forces\"].detach()\n return predictions\n\n predictions[\"forces\"] = np.array(predictions[\"forces\"], dtype=object)\n predictions[\"energy\"] = np.array(predictions[\"energy\"])\n predictions[\"id\"] = np.array(predictions[\"id\"])\n self.save_results(predictions, results_file, keys=[\"energy\", \"forces\"])\n return predictions\n\n def train(self):\n self.best_val_metric = -1.0\n eval_every = self.config[\"optim\"].get(\"eval_every\", -1)\n primary_metric = self.config[\"task\"].get(\n \"primary_metric\", self.evaluator.task_primary_metric[self.name]\n )\n iters = 0\n self.metrics = {}\n for epoch in range(self.config[\"optim\"][\"max_epochs\"]):\n self.model.train()\n for i, batch in enumerate(self.train_loader):\n # Forward, loss, backward.\n with torch.cuda.amp.autocast(enabled=self.scaler is not None):\n out = self._forward(batch)\n loss = self._compute_loss(out, batch)\n loss = self.scaler.scale(loss) if self.scaler else loss\n self._backward(loss)\n scale = self.scaler.get_scale() if self.scaler else 1.0\n\n # Compute metrics.\n self.metrics = self._compute_metrics(\n out,\n batch,\n self.evaluator,\n self.metrics,\n )\n self.metrics = self.evaluator.update(\n \"loss\", loss.item() / scale, self.metrics\n )\n\n # Print metrics, make plots.\n log_dict = {k: self.metrics[k][\"metric\"] for k in self.metrics}\n log_dict.update(\n {\"epoch\": epoch + (i + 1) / len(self.train_loader)}\n )\n if (\n i % self.config[\"cmd\"][\"print_every\"] == 0\n and distutils.is_master()\n ):\n log_str = [\n \"{}: {:.4f}\".format(k, v) for k, v in log_dict.items()\n ]\n print(\", \".join(log_str))\n self.metrics = {}\n\n if self.logger is not None:\n self.logger.log(\n log_dict,\n step=epoch * len(self.train_loader) + i + 1,\n split=\"train\",\n )\n\n iters += 1\n\n # Evaluate on val set every `eval_every` iterations.\n if eval_every != -1 and iters % eval_every == 0:\n if self.val_loader is not None:\n val_metrics = self.validate(\n split=\"val\",\n epoch=epoch - 1 + (i + 1) / len(self.train_loader),\n )\n if (\n val_metrics[primary_metric][\"metric\"]\n > self.best_val_metric\n ):\n self.best_val_metric = val_metrics[primary_metric][\n \"metric\"\n ]\n current_epoch = epoch + (i + 1) / len(\n self.train_loader\n )\n self.save(current_epoch, val_metrics)\n if self.test_loader is not None:\n self.predict(\n self.test_loader,\n results_file=\"predictions\",\n disable_tqdm=False,\n )\n\n self.scheduler.step()\n torch.cuda.empty_cache()\n\n if eval_every == -1:\n if self.val_loader is not None:\n val_metrics = self.validate(split=\"val\", epoch=epoch)\n if (\n val_metrics[primary_metric][\"metric\"]\n > self.best_val_metric\n ):\n self.best_val_metric = val_metrics[primary_metric][\n \"metric\"\n ]\n self.save(epoch + 1, val_metrics)\n if self.test_loader is not None:\n self.predict(\n self.test_loader,\n results_file=\"predictions\",\n disable_tqdm=False,\n )\n else:\n self.save(epoch + 1, self.metrics)\n\n def _forward(self, batch_list):\n # forward pass.\n if self.config[\"model_attributes\"].get(\"regress_forces\", True):\n out_energy, out_forces = self.model(batch_list)\n else:\n out_energy = self.model(batch_list)\n\n if out_energy.shape[-1] == 1:\n out_energy = out_energy.view(-1)\n\n out = {\n \"energy\": out_energy,\n }\n\n if self.config[\"model_attributes\"].get(\"regress_forces\", True):\n out[\"forces\"] = out_forces\n\n return out\n\n def _compute_loss(self, out, batch_list):\n loss = []\n\n # Energy loss.\n energy_target = torch.cat(\n [batch.y.to(self.device) for batch in batch_list], dim=0\n )\n if self.config[\"dataset\"].get(\"normalize_labels\", False):\n energy_target = self.normalizers[\"target\"].norm(energy_target)\n energy_mult = self.config[\"optim\"].get(\"energy_coefficient\", 1)\n loss.append(energy_mult * self.criterion(out[\"energy\"], energy_target))\n\n # Force loss.\n if self.config[\"model_attributes\"].get(\"regress_forces\", True):\n force_target = torch.cat(\n [batch.force.to(self.device) for batch in batch_list], dim=0\n )\n if self.config[\"dataset\"].get(\"normalize_labels\", False):\n force_target = self.normalizers[\"grad_target\"].norm(\n force_target\n )\n\n # Force coefficient = 30 has been working well for us.\n force_mult = self.config[\"optim\"].get(\"force_coefficient\", 30)\n if self.config[\"task\"].get(\"train_on_free_atoms\", False):\n fixed = torch.cat(\n [batch.fixed.to(self.device) for batch in batch_list]\n )\n mask = fixed == 0\n loss.append(\n force_mult\n * self.criterion(out[\"forces\"][mask], force_target[mask])\n )\n else:\n loss.append(\n force_mult * self.criterion(out[\"forces\"], force_target)\n )\n\n # Sanity check to make sure the compute graph is correct.\n for lc in loss:\n assert hasattr(lc, \"grad_fn\")\n\n loss = sum(loss)\n return loss\n\n def _compute_metrics(self, out, batch_list, evaluator, metrics={}):\n natoms = torch.cat(\n [batch.natoms.to(self.device) for batch in batch_list], dim=0\n )\n\n target = {\n \"energy\": torch.cat(\n [batch.y.to(self.device) for batch in batch_list], dim=0\n ),\n \"forces\": torch.cat(\n [batch.force.to(self.device) for batch in batch_list], dim=0\n ),\n \"natoms\": natoms,\n }\n\n out[\"natoms\"] = natoms\n\n if self.config[\"task\"].get(\"eval_on_free_atoms\", True):\n fixed = torch.cat(\n [batch.fixed.to(self.device) for batch in batch_list]\n )\n mask = fixed == 0\n out[\"forces\"] = out[\"forces\"][mask]\n target[\"forces\"] = target[\"forces\"][mask]\n\n s_idx = 0\n natoms_free = []\n for natoms in target[\"natoms\"]:\n natoms_free.append(\n torch.sum(mask[s_idx : s_idx + natoms]).item()\n )\n s_idx += natoms\n target[\"natoms\"] = torch.LongTensor(natoms_free).to(self.device)\n out[\"natoms\"] = torch.LongTensor(natoms_free).to(self.device)\n\n if self.config[\"dataset\"].get(\"normalize_labels\", False):\n out[\"energy\"] = self.normalizers[\"target\"].denorm(out[\"energy\"])\n out[\"forces\"] = self.normalizers[\"grad_target\"].denorm(\n out[\"forces\"]\n )\n\n metrics = evaluator.eval(out, target, prev_metrics=metrics)\n return metrics\n\n def run_relaxations(self, split=\"val\", epoch=None):\n print(\"### Running ML-relaxations\")\n self.model.eval()\n\n evaluator, metrics = Evaluator(task=\"is2rs\"), {}\n\n if hasattr(self.relax_dataset[0], \"pos_relaxed\") and hasattr(\n self.relax_dataset[0], \"y_relaxed\"\n ):\n split = \"val\"\n else:\n split = \"test\"\n\n ids = []\n relaxed_positions = []\n for i, batch in tqdm(\n enumerate(self.relax_loader), total=len(self.relax_loader)\n ):\n relaxed_batch = ml_relax(\n batch=batch,\n model=self,\n steps=self.config[\"task\"].get(\"relaxation_steps\", 200),\n fmax=self.config[\"task\"].get(\"relaxation_fmax\", 0.0),\n relax_opt=self.config[\"task\"][\"relax_opt\"],\n device=self.device,\n transform=None,\n )\n\n if self.config[\"task\"].get(\"write_pos\", False):\n systemids = [str(i) for i in relaxed_batch.sid.tolist()]\n natoms = relaxed_batch.natoms.tolist()\n positions = torch.split(relaxed_batch.pos, natoms)\n batch_relaxed_positions = [pos.tolist() for pos in positions]\n\n relaxed_positions += batch_relaxed_positions\n ids += systemids\n\n if split == \"val\":\n mask = relaxed_batch.fixed == 0\n s_idx = 0\n natoms_free = []\n for natoms in relaxed_batch.natoms:\n natoms_free.append(\n torch.sum(mask[s_idx : s_idx + natoms]).item()\n )\n s_idx += natoms\n\n target = {\n \"energy\": relaxed_batch.y_relaxed,\n \"positions\": relaxed_batch.pos_relaxed[mask],\n \"cell\": relaxed_batch.cell,\n \"pbc\": torch.tensor([True, True, True]),\n \"natoms\": torch.LongTensor(natoms_free),\n }\n\n prediction = {\n \"energy\": relaxed_batch.y,\n \"positions\": relaxed_batch.pos[mask],\n \"cell\": relaxed_batch.cell,\n \"pbc\": torch.tensor([True, True, True]),\n \"natoms\": torch.LongTensor(natoms_free),\n }\n\n metrics = evaluator.eval(prediction, target, metrics)\n\n if self.config[\"task\"].get(\"write_pos\", False):\n rank = distutils.get_rank()\n pos_filename = os.path.join(\n self.config[\"cmd\"][\"results_dir\"], f\"relaxed_pos_{rank}.npz\"\n )\n np.savez_compressed(\n pos_filename,\n ids=ids,\n pos=np.array(relaxed_positions, dtype=object),\n )\n\n distutils.synchronize()\n if distutils.is_master():\n gather_results = defaultdict(list)\n full_path = os.path.join(\n self.config[\"cmd\"][\"results_dir\"],\n \"relaxed_positions.npz\",\n )\n\n for i in range(distutils.get_world_size()):\n rank_path = os.path.join(\n self.config[\"cmd\"][\"results_dir\"],\n f\"relaxed_pos_{i}.npz\",\n )\n rank_results = np.load(rank_path, allow_pickle=True)\n gather_results[\"ids\"].extend(rank_results[\"ids\"])\n gather_results[\"pos\"].extend(rank_results[\"pos\"])\n os.remove(rank_path)\n\n # Because of how distributed sampler works, some system ids\n # might be repeated to make no. of samples even across GPUs.\n _, idx = np.unique(gather_results[\"ids\"], return_index=True)\n gather_results[\"ids\"] = np.array(gather_results[\"ids\"])[idx]\n gather_results[\"pos\"] = np.array(\n gather_results[\"pos\"], dtype=object\n )[idx]\n\n print(f\"Writing results to {full_path}\")\n np.savez_compressed(full_path, **gather_results)\n\n if split == \"val\":\n aggregated_metrics = {}\n for k in metrics:\n aggregated_metrics[k] = {\n \"total\": distutils.all_reduce(\n metrics[k][\"total\"], average=False, device=self.device\n ),\n \"numel\": distutils.all_reduce(\n metrics[k][\"numel\"], average=False, device=self.device\n ),\n }\n aggregated_metrics[k][\"metric\"] = (\n aggregated_metrics[k][\"total\"]\n / aggregated_metrics[k][\"numel\"]\n )\n metrics = aggregated_metrics\n\n # Make plots.\n log_dict = {k: metrics[k][\"metric\"] for k in metrics}\n if self.logger is not None and epoch is not None:\n self.logger.log(\n log_dict,\n step=(epoch + 1) * len(self.train_loader),\n split=split,\n )\n\n if distutils.is_master():\n print(metrics)\n"
] | [
[
"torch.cuda.empty_cache",
"torch.utils.data.DataLoader",
"numpy.load",
"torch.sum",
"torch.split",
"torch.tensor",
"torch.cuda.amp.autocast",
"numpy.array",
"torch.LongTensor",
"torch.cat",
"numpy.unique",
"numpy.savez_compressed"
]
] |
naivelogic/ZeroWaste3D | [
"915d4a37563db8481c8631ab0e34cfd0512941f8"
] | [
"DataManager/Legacy/create_dataset/generate_mask_db.py"
] | [
"#%%\nimport sys, os, glob\nimport numpy as np\nsys.path.append(\"../\") # go to parent dir\n\nfrom utils.coco_manager import MaskManager\n\n\n## Create Train/Val/Test/ Datasets\n#Train: 80% \n#Val: 18%\n#Test: 2%\n\n#%%\nDATASET_VERSON = 'ds2'\nDATASET_PATH = f'/mnt/zerowastepublic/02-datasets/{DATASET_VERSON}/'\nDATASET_RAW_FOLDER = f'/mnt/zerowastepublic/02-datasets/{DATASET_VERSON}/raw/'\n\n# debug for nocs - 7/15\nDATASET_PATH = f'/mnt/daredevildiag/6PACK/z3d/ds1/InstanceGroup2Desccamera_0camera_Shape0_iter0/'\nDATASET_RAW_FOLDER = f'/mnt/daredevildiag/6PACK/z3d/ds1/'\n\n# debug for water waste - 10/15/20\nDATASET_PATH = f'/home/redne/ZeroWaste3D/DataManager/create_dataset/sample_maya_raw/ds1/'\nDATASET_RAW_FOLDER = f'/home/redne/ZeroWaste3D/DataManager/create_dataset/sample_maya_raw/ds1/raw/'\n\n\n\nfrom sklearn.model_selection import train_test_split\ndir_list = os.listdir(DATASET_RAW_FOLDER)\ntrain, val = train_test_split(dir_list, test_size=0.2, random_state=31)\nval, test = train_test_split(val, test_size=0.1, random_state=31)\n\nprint(f'training dataset size: {len(train)}\\nvalidation dataset size: {len(val)}\\ntest dataset size: {len(test)}')\n\n\n\n#%%\n# debug for nocs - 7/15\n#train = ['/mnt/daredevildiag/6PACK/z3d/ds1/raw/InstanceGroup2Desccamera_0camera_Shape0_iter0/']\ntrain = ['InstanceGroup2Desccamera_0camera_Shape0_iter0']\n#DATASET_PATH = '/mnt/daredevildiag/6PACK/z3d/ds1/'\nDATASET_PATH = f'/home/redne/ZeroWaste3D/DataManager/create_dataset/sample_maya_raw/ds1/'\ndef mask_runner(dataset_paths, phase):\n m = MaskManager(DATASET_PATH)\n\n m.dataset_raw_folder = os.path.join(DATASET_PATH, 'raw')\n\n # save new mask & images\n m.custom_classes_flag = True\n m.resave_masks = True\n m.resave_mask_path = os.path.join(DATASET_PATH, 'masks')\n\n m.resave_images_flag = True\n m.resave_images_path = os.path.join(DATASET_PATH, 'images')\n\n\n m.custom_classes = {\n \"H_beveragebottle\": \"H_beveragebottle\",\n \"D_lid\": \"D_lid\",\n \"S_cup\": \"S_cup\"\n }\n m.colorMapping = {\n \"H_beveragebottle\": [0, 255, 0],\n 'D_lid': [255, 0, 0],\n 'S_cup': [0, 0, 255]\n }\n m.mask_colors = {\n \"H_beveragebottle\": (0, 255, 0),\n \"D_lid\": (255, 0, 0),\n \"S_cup\": (0, 0, 255),\n }\n m.super_categories = {\n \"H_beveragebottle\": \"H_beveragebottle\",\n \"D_lid\": \"D_lid\",\n \"S_cup\": \"S_cup\"\n }\n m.get_super_categories = {\n \"H_beveragebottle\": [\"H_beveragebottle\"],\n \"D_lid\": [\"D_lid\"],\n \"S_cup\": [\"S_cup\"]\n }\n \n m.start(phase=phase, mask_paths=dataset_paths)\n\n print(f'there are {len(m.masks)} images')\n m.show_mask_img(len(m.masks)-1)\n m.write_masks_to_json(phase=phase)\n\n#%%\nmask_runner(train, 'train') # debug for nocs - 7/15\n#mask_runner(train, 'ds2_3c_train')\n\n#%%\nmask_runner(test, 'ds2_3c_test')\n\n#%%\nmask_runner(val, 'ds2_3c_val')\n\n\n\"\"\"\npython coco_json_utils.py -md /mnt/zerowastepublic/02-datasets/ds2/dataset_config/ds2_3c_test_mask_definitions.json -di /home/redne/mnt/project_zero/project_zero/ds1/experiments/dataset_config/dataset_info.json -ph ds2_3c_test -dp /mnt/zerowastepublic/02-datasets/ds2/dataset_config/\n\n\npython coco_json_utils.py -md /mnt/daredevildiag/6PACK/z3d/ds1/dataset_config/train_mask_definitions.json -di dataset_info.json -ph train -dp /mnt/daredevildiag/6PACK/z3d/ds1/dataset_config/\n\"\"\""
] | [
[
"sklearn.model_selection.train_test_split"
]
] |
bobrokerson/libraries | [
"996509d341af7108a24053eb88431ec6afbb0f25"
] | [
"assignment/min_nonsmooth_fun.py"
] | [
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Fri Jan 21 15:36:06 2022\n\n@author: bobrokerson\n\"\"\"\n# part of code from task #1\n\nfrom math import sin, exp\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\ndef func(x):\n return sin(x / 5.) * exp(x / 10.) + 5. * exp(-x/ 2.)\n\n\nxarr = np.arange(1., 31.)\nprint(xarr)\nprint(\"x:\", xarr.shape)\nyarr = np.array([func(x) for x in xarr])\nprint(yarr)\nprint(\"y:\", yarr.shape)\n\nplt.plot(xarr, yarr)\nplt.grid(True)\nplt.axis([0, 30, -15, 5])\nplt.show()\n\n\n# 1.Теперь рассмотрим функцию h(x) = int(f(x)) на том же отрезке [1, 30], т.е. теперь каждое значение f(x) приводится к типу int и функция принимает только целые значения.\n# 2.Такая функция будет негладкой и даже разрывной, а ее график будет иметь ступенчатый вид. Убедитесь в этом, построив график h(x) с помощью matplotlib.\n# 3.Попробуйте найти минимум функции h(x) с помощью BFGS, взяв в качестве начального приближения x=30. Получившееся значение функции – ваш первый ответ в этой задаче.\n# 4.Теперь попробуйте найти минимум h(x) на отрезке [1, 30] с помощью дифференциальной эволюции. Значение функции h(x) в точке минимума – это ваш второй ответ в этом задании. Запишите его через пробел после предыдущего.\n# 5.Обратите внимание на то, что полученные ответы различаются. Это ожидаемый результат, ведь BFGS использует градиент (в одномерном случае – производную) и явно не пригоден для минимизации рассмотренной нами разрывной функции. Попробуйте понять, почему минимум, найденный BFGS, именно такой (возможно в этом вам поможет выбор разных начальных приближений).\n# 6.Выполнив это задание, вы увидели на практике, чем поиск минимума функции отличается от глобальной оптимизации, и когда может быть полезно применить вместо градиентного метода оптимизации метод, не использующий градиент. Кроме того, вы попрактиковались в использовании библиотеки SciPy для решения оптимизационных задач, и теперь знаете, насколько это просто и удобно.\n\nfrom scipy.optimize import minimize\nfrom scipy.optimize import differential_evolution\n\ndef funcnew(x): \n return int(func(x))\n\nxarrnew = np.arange(1., 31., 0.01)\nprint(xarrnew)\nprint(\"x:\", xarrnew.shape)\nyarrnew = np.array([funcnew(x) for x in xarrnew])\nprint(yarrnew)\nprint(\"y:\", yarrnew.shape)\n\n# create plot\nplt.plot(xarrnew, yarrnew)\nplt.grid(True)\nplt.axis([0, 30, -15, 5])\nplt.show()\n\n\nminFuncnewVal1 = minimize(funcnew, 30, method = 'BFGS')\nprint(\"Min f(x) BFGS method: \", round(minFuncnewVal1.fun, 3), \"for x = \", minFuncnewVal1.x)\nprint(\"Number: \", minFuncnewVal1.nit)\n\nminValR2 = np.zeros( (2) )\nminValR2 [0] = round(minFuncnewVal1.fun, 2)\nprint(minValR2)\n\n# searching min h(x)\n\nbounds = [(1, 30)]\nminFuncnewVal2 = differential_evolution(funcnew, bounds)\nprint(\"Min f(x) BFGS method: \", round(minFuncnewVal2.fun, 3), \"for x = \", minFuncnewVal2.x)\nprint(\"Number: \", minFuncnewVal2.nit)\n\nminValR2[1] = round(minFuncnewVal2.fun, 2)\nprint (minValR2)\n\nwith open(\"docvalue3.txt\", \"w\") as file:\n for item in minValR2:\n file.write(str(item) + ' ')\n S\n"
] | [
[
"numpy.zeros",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.axis",
"scipy.optimize.minimize",
"numpy.arange",
"scipy.optimize.differential_evolution",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot"
]
] |
Poezedoez/NearestNeighBERT-Faiss | [
"802c9528105295abe28be8624c7582a3c0f68835"
] | [
"nearest_neighbert/evaluate.py"
] | [
"from sklearn.metrics import precision_recall_fscore_support as prfs\nimport numpy as np\nimport json\nimport argparse\nfrom typing import List, Tuple, Dict\nimport sys\n\n# From spert.evaluator class\n# https://github.com/markus-eberts/spert/blob/master/spert/evaluator.py\n\ndef _get_row(data, label):\n row = [label]\n for i in range(len(data) - 1):\n row.append(\"%.2f\" % (data[i] * 100))\n row.append(data[3])\n return tuple(row)\n\ndef _print_results(per_type: List, micro: List, macro: List, types: List):\n columns = ('type', 'precision', 'recall', 'f1-score', 'support')\n\n row_fmt = \"%20s\" + (\" %12s\" * (len(columns) - 1))\n results = [row_fmt % columns, '\\n']\n\n metrics_per_type = []\n for i, t in enumerate(types):\n metrics = []\n for j in range(len(per_type)):\n metrics.append(per_type[j][i])\n metrics_per_type.append(metrics)\n\n for m, t in zip(metrics_per_type, types):\n results.append(row_fmt % _get_row(m, t))\n results.append('\\n')\n\n results.append('\\n')\n\n # micro\n results.append(row_fmt % _get_row(micro, 'micro'))\n results.append('\\n')\n\n # macro\n results.append(row_fmt % _get_row(macro, 'macro'))\n\n results_str = ''.join(results)\n print(results_str)\n\ndef _compute_metrics(gt_all, pred_all, types, print_results: bool = False):\n labels = [t for t in types]\n per_type = prfs(gt_all, pred_all, labels=labels, average=None)\n micro = prfs(gt_all, pred_all, labels=labels, average='micro')[:-1]\n macro = prfs(gt_all, pred_all, labels=labels, average='macro')[:-1]\n total_support = sum(per_type[-1])\n\n if print_results:\n _print_results(per_type, list(micro) + [total_support], list(macro) + [total_support], types)\n\n return [m * 100 for m in micro + macro]\n\n## Tuple = (start, end, entity_type)\n\ndef _score(gt: List[List[Tuple]], pred: List[List[Tuple]], print_results: bool = False):\n assert len(gt) == len(pred)\n\n gt_flat = []\n pred_flat = []\n types = set()\n\n for (sample_gt, sample_pred) in zip(gt, pred):\n union = set()\n union.update(sample_gt)\n union.update(sample_pred)\n\n for s in union:\n if s in sample_gt:\n t = s[2]\n gt_flat.append(t)\n types.add(t)\n else:\n gt_flat.append(\"0\")\n\n if s in sample_pred:\n t = s[2]\n pred_flat.append(t)\n types.add(t)\n else:\n pred_flat.append(\"0\")\n metrics = _compute_metrics(gt_flat, pred_flat, types, print_results)\n\n return metrics\n\ndef _convert_span_tuples(sequence):\n span_tuples = []\n entities = sequence[\"entities\"]\n for span in entities:\n tuple_ = (span[\"start\"], span[\"end\"], span[\"type\"])\n span_tuples.append(tuple_)\n \n return span_tuples\n\ndef _convert_token_tuples(sequence):\n token_tuples = []\n entities = sequence[\"entities\"]\n string_tokens = sequence[\"tokens\"]\n for span in entities:\n span_range = range(span[\"start\"], span[\"end\"])\n for index in span_range:\n tuple_ = (index, index+1, span[\"type\"])\n token_tuples.append(tuple_)\n \n return token_tuples\n\ndef evaluate(gt_path, pred_path, tokenizer, print_results=True):\n with open(gt_path, 'r', encoding='utf-8') as f:\n gt_dataset = json.load(f)\n\n with open(pred_path, 'r', encoding='utf-8') as f:\n pred_dataset = json.load(f)\n\n gt_spans = []\n pred_spans = []\n gt_tokens = []\n pred_tokens = []\n\n for gt_sequence, pred_sequence in zip(gt_dataset, pred_dataset):\n gt_spans.append(_convert_span_tuples(gt_sequence))\n pred_spans.append(_convert_span_tuples(pred_sequence))\n gt_tokens.append(_convert_token_tuples(gt_sequence))\n pred_tokens.append(_convert_token_tuples(pred_sequence))\n \n \n print(\"\")\n print(\"--- Entities (named entity recognition (NER)) ---\")\n print(\"An entity span is considered correct if the entity type and span start/end is predicted correctly\")\n ner_span_eval = _score(gt_spans, pred_spans, print_results=print_results)[:3]\n print(\"\")\n print(\"An entity token is considered correct if the entity type is predicted correctly\")\n ner_token_eval = _score(gt_tokens, pred_tokens, print_results=print_results)[:3]\n print(\"\")\n\n return ner_span_eval, ner_token_eval\n\n\ndef compare_datasets(gt_path, pred_path, output_path=None):\n with open(gt_path, 'r', encoding='utf-8') as f:\n gt_dataset = json.load(f)\n\n with open(pred_path, 'r', encoding='utf-8') as f:\n pred_dataset = json.load(f)\n\n assert len(gt_dataset)==len(pred_dataset)\n\n file_object = open(output_path, 'w', encoding='utf-8') if output_path else sys.stdout\n for gt_sentence, pred_sentence in zip(gt_dataset, pred_dataset):\n gt_tokens = gt_sentence[\"tokens\"]\n print(\"|{}| {} \\n\".format(gt_sentence[\"orig_id\"], \" \".join(gt_tokens)), file=file_object)\n for entity in gt_sentence[\"entities\"]:\n entity_tokens = gt_tokens[entity[\"start\"]:entity[\"end\"]]\n line = \"[gold] \\t {} \\t {}\".format(\" \".join(entity_tokens), entity[\"type\"])\n print(line, file=file_object)\n pred_tokens = pred_sentence[\"tokens\"]\n for entity in pred_sentence[\"entities\"]:\n entity_tokens = pred_tokens[entity[\"start\"]:entity[\"end\"]]\n line = \"[pred] \\t {} \\t {}\".format(\" \".join(entity_tokens), entity[\"type\"])\n print(line, file=file_object)\n print('-'*50, file=file_object)\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description='Evaluate spert json formatted dataset')\n parser.add_argument('gt_path', type=str, help='path to the ground truth dataset.json file')\n parser.add_argument('pred_path', type=str, help='path to the predicted dataset.json file')\n args = parser.parse_args()\n evaluate(args.gt_path, args.pred_path)\n "
] | [
[
"sklearn.metrics.precision_recall_fscore_support"
]
] |
eternagame/KaggleOpenVaccine | [
"de252988b92dc2c673a80347deb8827a12aa2ad8"
] | [
"data/mRNA_233x_data/reformat_kazuki2.py"
] | [
"import numpy as np\nimport pandas as pd\nimport gzip\n\ninput_file = 'predictions/2nd-place-233-seq.csv'\nnickname='kazuki2'\n\ndf = pd.read_csv('../233x_sequences_degdata_081120.csv')\ndf1 = pd.read_csv(input_file)\n\ndf1['ID'] = [int(x.split('_')[0]) for x in df1['id_seqpos']]\ndf1['seqpos'] = [int(x.split('_')[1]) for x in df1['id_seqpos']]\n\ndf1['startpos'] = df['startpos']\ndf1['endpos'] = df['endpos']\n\nfor data_type in ['reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C','deg_50C']:\n output_array = np.ones([233,1588])*np.NaN\n\n for _, row in df1.iterrows():\n output_array[row['ID'],row['seqpos']] = row[data_type]\n\n np.savetxt('formatted_predictions/%s_%s_flat_FULL_233x.csv' % (nickname, data_type),output_array, delimiter=',')\n\n for i, row in df1.iterrows():\n if not np.isnan(row['startpos']):\n output_array[i, :int(row['startpos'])] = np.NaN\n output_array[i, int(row['endpos']):] = np.NaN\n \n np.savetxt('formatted_predictions/%s_%s_flat_PCR_233x.csv' % (nickname, data_type),output_array, delimiter=',')\n"
] | [
[
"pandas.read_csv",
"numpy.savetxt",
"numpy.ones",
"numpy.isnan"
]
] |
karl-zhao/benchmarking-gnns-pyg | [
"23d2c823f16ead554b22ff31c41d5bd8074b133e"
] | [
"nets/SBMs_node_classification/mo_net.py"
] | [
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n# from torch_scatter import scatter_add\n# from num_nodes import maybe_num_nodes\nimport dgl\nfrom torch_geometric.nn.conv import MessagePassing\nimport numpy as np\nimport torch.nn as nn\nfrom torch import Tensor\n# from torch_geometric.utils import degree\nfrom torch_scatter import scatter_add\n\n\"\"\"\n GMM: Gaussian Mixture Model Convolution layer\n Geometric Deep Learning on Graphs and Manifolds using Mixture Model CNNs (Federico Monti et al., CVPR 2017)\n https://arxiv.org/pdf/1611.08402.pdf\n\"\"\"\n\nfrom layers.gmm_layer import GMMLayer\nfrom layers.mlp_readout_layer import MLPReadout\nfrom torch_geometric.nn import GMMConv\n\nclass MoNet(nn.Module):\n def __init__(self, net_params):\n super().__init__()\n self.name = 'MoNet'\n in_dim = net_params['in_dim']\n hidden_dim = net_params['hidden_dim']\n out_dim = net_params['out_dim']\n kernel = net_params['kernel'] # for MoNet\n dim = net_params['pseudo_dim_MoNet'] # for MoNet\n n_classes = net_params['n_classes']\n dropout = net_params['dropout']\n n_layers = net_params['L']\n self.readout = net_params['readout'] \n batch_norm = net_params['batch_norm']\n residual = net_params['residual'] \n self.device = net_params['device']\n self.n_classes = n_classes\n \n aggr_type = \"sum\" # default for MoNet\n \n self.embedding_h = nn.Embedding(in_dim, hidden_dim)\n \n self.layers = nn.ModuleList()\n self.pseudo_proj = nn.ModuleList()\n\n # Hidden layer\n for _ in range(n_layers-1):\n self.layers.append(GMMLayer(hidden_dim, hidden_dim, dim, kernel, aggr_type,\n dropout, batch_norm, residual))\n self.pseudo_proj.append(nn.Sequential(nn.Linear(2, dim), nn.Tanh()))\n \n # Output layer\n self.layers.append(GMMLayer(hidden_dim, out_dim, dim, kernel, aggr_type,\n dropout, batch_norm, residual))\n self.pseudo_proj.append(nn.Sequential(nn.Linear(2, dim), nn.Tanh()))\n \n self.MLP_layer = MLPReadout(out_dim, n_classes)\n\n def forward(self, g, h, e):\n h = self.embedding_h(h)\n\n # computing the 'pseudo' named tensor which depends on node degrees\n g.ndata['deg'] = g.in_degrees()\n g.apply_edges(self.compute_pseudo)\n pseudo = g.edata['pseudo'].to(self.device).float()\n \n for i in range(len(self.layers)):\n h = self.layers[i](g, h, self.pseudo_proj[i](pseudo))\n\n return self.MLP_layer(h)\n \n def compute_pseudo(self, edges):\n # compute pseudo edge features for MoNet\n # to avoid zero division in case in_degree is 0, we add constant '1' in all node degrees denoting self-loop\n # srcs = 1/np.sqrt((edges.src['deg']+1).cpu())\n # dsts = 1/np.sqrt((edges.src['deg']+1).cpu())\n srcs = 1 / (edges.src['deg'] + 1).float().sqrt()\n dsts = 1 / (edges.src['deg'] + 1).float().sqrt()\n pseudo = torch.cat((srcs.unsqueeze(-1), dsts.unsqueeze(-1)), dim=1)\n return {'pseudo': pseudo}\n \n def loss(self, pred, label):\n\n # calculating label weights for weighted loss computation\n V = label.size(0)\n label_count = torch.bincount(label)\n label_count = label_count[label_count.nonzero()].squeeze()\n cluster_sizes = torch.zeros(self.n_classes).long().to(self.device)\n cluster_sizes[torch.unique(label)] = label_count\n weight = (V - cluster_sizes).float() / V\n weight *= (cluster_sizes>0).float()\n \n # weighted cross-entropy for unbalanced classes\n criterion = nn.CrossEntropyLoss(weight=weight)\n loss = criterion(pred, label)\n\n return loss\n\n\"\"\"\n GMM: Gaussian Mixture Model Convolution layer\n Geometric Deep Learning on Graphs and Manifolds using Mixture Model CNNs (Federico Monti et al., CVPR 2017)\n https://arxiv.org/pdf/1611.08402.pdf\n\"\"\"\nclass MoNetNet_pyg(MessagePassing):\n def __init__(self, net_params):\n super().__init__()\n self.name = 'MoNet'\n in_dim = net_params['in_dim']\n hidden_dim = net_params['hidden_dim']\n out_dim = net_params['out_dim']\n kernel = net_params['kernel'] # for MoNet\n dim = net_params['pseudo_dim_MoNet'] # for MoNet\n n_classes = net_params['n_classes']\n self.dropout = net_params['dropout']\n self.n_layers = net_params['L']\n self.readout = net_params['readout']\n self.batch_norm = net_params['batch_norm']\n self.residual = net_params['residual']\n self.device = net_params['device']\n self.n_classes = n_classes\n self.dim = dim\n # aggr_type = \"sum\" # default for MoNet\n aggr_type = \"mean\"\n\n self.embedding_h = nn.Embedding(in_dim, hidden_dim)\n self.layers = nn.ModuleList()\n self.pseudo_proj = nn.ModuleList()\n self.batchnorm_h = nn.ModuleList()\n # Hidden layer\n for _ in range(self.n_layers - 1):\n self.layers.append(GMMConv(hidden_dim, hidden_dim, dim, kernel, separate_gaussians = False ,aggr = aggr_type,\n root_weight = True, bias = True))\n if self.batch_norm:\n self.batchnorm_h.append(nn.BatchNorm1d(hidden_dim))\n self.pseudo_proj.append(nn.Sequential(nn.Linear(2, dim), nn.Tanh()))\n # Output layer\n self.layers.append(GMMConv(hidden_dim, out_dim, dim, kernel, separate_gaussians = False ,aggr = aggr_type,\n root_weight = True, bias = True))\n if self.batch_norm:\n self.batchnorm_h.append(nn.BatchNorm1d(out_dim))\n self.pseudo_proj.append(nn.Sequential(nn.Linear(2, dim), nn.Tanh()))\n self.MLP_layer = MLPReadout(out_dim, n_classes)\n # to do\n\n def forward(self, h, edge_index, e):\n h = self.embedding_h(h)\n edge_weight = torch.ones((edge_index.size(1),),\n device = edge_index.device)\n row, col = edge_index[0], edge_index[1]\n deg = scatter_add(edge_weight, row, dim=0, dim_size=h.size(0))\n deg_inv_sqrt = deg.pow_(-0.5)\n deg_inv_sqrt.masked_fill_(deg_inv_sqrt == float('inf'), 0)\n pseudo = torch.cat((deg_inv_sqrt[row].unsqueeze(-1), deg_inv_sqrt[col].unsqueeze(-1)), dim=1)\n\n for i in range(self.n_layers):\n h_in = h\n h = self.layers[i](h, edge_index, self.pseudo_proj[i](pseudo))\n if self.batch_norm:\n h = self.batchnorm_h[i](h) # batch normalization\n h = F.relu(h) # non-linear activation\n if self.residual:\n h = h_in + h # residual connection\n h = F.dropout(h, self.dropout, training=self.training)\n\n return self.MLP_layer(h)\n\n\n def loss(self, pred, label):\n\n # calculating label weights for weighted loss computation\n V = label.size(0)\n label_count = torch.bincount(label)\n label_count = label_count[label_count.nonzero()].squeeze()\n cluster_sizes = torch.zeros(self.n_classes).long().to(self.device)\n cluster_sizes[torch.unique(label)] = label_count\n weight = (V - cluster_sizes).float() / V\n weight *= (cluster_sizes > 0).float()\n\n # weighted cross-entropy for unbalanced classes\n criterion = nn.CrossEntropyLoss(weight=weight)\n loss = criterion(pred, label)\n\n return loss"
] | [
[
"torch.nn.Linear",
"torch.nn.functional.dropout",
"torch.nn.BatchNorm1d",
"torch.bincount",
"torch.nn.Embedding",
"torch.nn.CrossEntropyLoss",
"torch.nn.functional.relu",
"torch.nn.Tanh",
"torch.nn.ModuleList",
"torch.unique",
"torch.zeros"
]
] |
teo-milea/federated | [
"ce0707a954a531860eb38864b44d7b748fd62aa7"
] | [
"tensorflow_federated/python/core/impl/execution_contexts/async_execution_context_test.py"
] | [
"# Copyright 2021, The TensorFlow Federated 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\nimport asyncio\nimport numpy as np\nimport tensorflow as tf\n\nfrom tensorflow_federated.python.core.api import computations\nfrom tensorflow_federated.python.core.impl.context_stack import get_context_stack\nfrom tensorflow_federated.python.core.impl.execution_contexts import async_execution_context\nfrom tensorflow_federated.python.core.impl.executors import executor_stacks\nfrom tensorflow_federated.python.core.impl.executors import executors_errors\nfrom tensorflow_federated.python.core.impl.types import computation_types\nfrom tensorflow_federated.python.core.impl.types import placements\n\n\nclass RetryableErrorTest(tf.test.TestCase):\n\n def test_is_retryable_error(self):\n retryable_error = executors_errors.RetryableError()\n self.assertTrue(\n async_execution_context._is_retryable_error(retryable_error))\n self.assertFalse(async_execution_context._is_retryable_error(TypeError()))\n self.assertFalse(async_execution_context._is_retryable_error(1))\n self.assertFalse(async_execution_context._is_retryable_error('a'))\n self.assertFalse(async_execution_context._is_retryable_error(None))\n\n\nclass UnwrapValueTest(tf.test.TestCase):\n\n def test_tensor(self):\n result = async_execution_context._unwrap(tf.constant(1))\n self.assertIsInstance(result, np.int32)\n result = async_execution_context._unwrap(tf.constant([1, 2]))\n self.assertIsInstance(result, np.ndarray)\n self.assertAllEqual(result, [1, 2])\n\n def test_structure_of_tensors(self):\n result = async_execution_context._unwrap([tf.constant(x) for x in range(5)])\n self.assertIsInstance(result, list)\n for x in range(5):\n self.assertIsInstance(result[x], np.int32)\n self.assertEqual(result[x], x)\n\n\nclass AsyncContextInstallationTest(tf.test.TestCase):\n\n def test_install_and_execute_in_context(self):\n factory = executor_stacks.local_executor_factory()\n context = async_execution_context.AsyncExecutionContext(factory)\n\n @computations.tf_computation(tf.int32)\n def add_one(x):\n return x + 1\n\n with get_context_stack.get_context_stack().install(context):\n val_coro = add_one(1)\n self.assertTrue(asyncio.iscoroutine(val_coro))\n self.assertEqual(asyncio.run(val_coro), 2)\n\n def test_install_and_execute_computations_with_different_cardinalities(self):\n factory = executor_stacks.local_executor_factory()\n context = async_execution_context.AsyncExecutionContext(factory)\n\n @computations.federated_computation(\n computation_types.FederatedType(tf.int32, placements.CLIENTS))\n def repackage_arg(x):\n return [x, x]\n\n with get_context_stack.get_context_stack().install(context):\n single_val_coro = repackage_arg([1])\n second_val_coro = repackage_arg([1, 2])\n self.assertTrue(asyncio.iscoroutine(single_val_coro))\n self.assertTrue(asyncio.iscoroutine(second_val_coro))\n self.assertEqual(\n [asyncio.run(single_val_coro),\n asyncio.run(second_val_coro)], [[[1], [1]], [[1, 2], [1, 2]]])\n\n\nif __name__ == '__main__':\n tf.test.main()\n"
] | [
[
"tensorflow.constant",
"tensorflow.test.main"
]
] |
naylor-b/blue | [
"709401e535cf6933215abd942d4b4d49dbf61b2b"
] | [
"openmdao/matrices/dense_matrix.py"
] | [
"\"\"\"Define the DenseMatrix class.\"\"\"\nfrom __future__ import division, print_function\nimport numpy as np\nfrom numpy import ndarray\nfrom six import iteritems\n\nfrom scipy.sparse import coo_matrix\n\nfrom openmdao.matrices.coo_matrix import COOMatrix\n\n# NOTE: DenseMatrix is inherited from COOMatrix so that we can easily handle use cases\n# where partials overlap the same matrix entries, as in the case of repeated\n# src_indices entries. This does require additional memory above storing just\n# the dense matrix, but it's worth it because the code is simpler and more robust.\n\n\nclass DenseMatrix(COOMatrix):\n \"\"\"\n Dense global matrix.\n \"\"\"\n\n def _build(self, num_rows, num_cols, in_ranges, out_ranges):\n \"\"\"\n Allocate the matrix.\n\n Parameters\n ----------\n num_rows : int\n number of rows in the matrix.\n num_cols : int\n number of cols in the matrix.\n in_ranges : dict\n Maps input var name to column range.\n out_ranges : dict\n Maps output var name to row range.\n \"\"\"\n super(DenseMatrix, self)._build(num_rows, num_cols, in_ranges, out_ranges)\n self._coo = self._matrix\n\n def _prod(self, in_vec, mode, ranges, mask=None):\n \"\"\"\n Perform a matrix vector product.\n\n Parameters\n ----------\n in_vec : ndarray[:]\n incoming vector to multiply.\n mode : str\n 'fwd' or 'rev'.\n ranges : (int, int, int, int)\n Min row, max row, min col, max col for the current system.\n mask : ndarray of type bool, or None\n Array used to mask out part of the input vector.\n\n Returns\n -------\n ndarray[:]\n vector resulting from the product.\n \"\"\"\n # when we have a derivative based solver at a level below the\n # group that owns the AssembledJacobian, we need to use only\n # the part of the matrix that is relevant to the lower level\n # system.\n if ranges is None:\n mat = self._matrix\n else:\n rstart, rend, cstart, cend = ranges\n mat = self._matrix[rstart:rend, cstart:cend]\n\n if mode == 'fwd':\n if mask is None:\n return mat.dot(in_vec)\n else:\n inputs_masked = np.ma.array(in_vec, mask=mask)\n\n # Use the special dot product function from masking module so that we\n # ignore masked parts.\n return np.ma.dot(mat, inputs_masked)\n else: # rev\n if mask is None:\n return mat.T.dot(in_vec)\n else:\n # Mask need to be applied to ext_mtx so that we can ignore multiplication\n # by certain columns.\n mat_T = mat.T\n arrmask = np.zeros(mat_T.shape, dtype=np.bool)\n arrmask[mask, :] = True\n masked_mtx = np.ma.array(mat_T, mask=arrmask, fill_value=0.0)\n\n masked_product = np.ma.dot(masked_mtx, in_vec).flatten()\n return np.ma.filled(masked_product, fill_value=0.0)\n\n def _create_mask_cache(self, d_inputs):\n \"\"\"\n Create masking array for this matrix.\n\n Note: this only applies when this Matrix is an 'ext_mtx' inside of a\n Jacobian object.\n\n Parameters\n ----------\n d_inputs : Vector\n The inputs linear vector.\n\n Returns\n -------\n ndarray or None\n The mask array or None.\n \"\"\"\n if len(d_inputs._views) > len(d_inputs._names):\n sub = d_inputs._names\n mask = np.ones(len(d_inputs), dtype=np.bool)\n for key, val in iteritems(self._metadata):\n if key[1] in sub:\n mask[val[1]] = False\n\n return mask\n\n def _pre_update(self):\n \"\"\"\n Do anything that needs to be done at the end of AssembledJacobian._update.\n \"\"\"\n self._matrix = self._coo\n\n def _post_update(self):\n \"\"\"\n Do anything that needs to be done at the end of AssembledJacobian._update.\n \"\"\"\n # this will add any repeated entries together\n self._matrix = self._coo.toarray()\n"
] | [
[
"numpy.ma.array",
"numpy.ma.dot",
"numpy.zeros",
"numpy.ma.filled"
]
] |
WERimagin/baseline_CoQA | [
"d11d19283b4c9b9b15cfcdb96bf5cd262bb953e8"
] | [
"rc/models/drqa.py"
] | [
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom .layers import SeqAttnMatch, StackedBRNN, LinearSeqAttn, BilinearSeqAttn\nfrom .layers import weighted_avg, uniform_weights, dropout\n\n\nclass DrQA(nn.Module):\n \"\"\"Network for the Document Reader module of DrQA.\"\"\"\n _RNN_TYPES = {'lstm': nn.LSTM, 'gru': nn.GRU, 'rnn': nn.RNN}\n\n def __init__(self, config, w_embedding):\n \"\"\"Configuration, word embeddings\"\"\"\n super(DrQA, self).__init__()\n # Store config\n self.config = config\n self.w_embedding = w_embedding\n input_w_dim = self.w_embedding.embedding_dim\n q_input_size = input_w_dim\n if self.config['fix_embeddings']:\n for p in self.w_embedding.parameters():\n p.requires_grad = False\n\n # Projection for attention weighted question\n if self.config['use_qemb']:\n self.qemb_match = SeqAttnMatch(input_w_dim)\n\n # Input size to RNN: word emb + question emb + manual features\n doc_input_size = input_w_dim + self.config['num_features']\n if self.config['use_qemb']:\n doc_input_size += input_w_dim\n\n # Project document and question to the same size as their encoders\n if self.config['resize_rnn_input']:\n self.doc_linear = nn.Linear(doc_input_size, config['hidden_size'], bias=True)\n self.q_linear = nn.Linear(input_w_dim, config['hidden_size'], bias=True)\n doc_input_size = q_input_size = config['hidden_size']\n\n # RNN document encoder\n self.doc_rnn = StackedBRNN(\n input_size=doc_input_size,\n hidden_size=config['hidden_size'],\n num_layers=config['num_layers'],\n dropout_rate=config['dropout_rnn'],\n dropout_output=config['dropout_rnn_output'],\n variational_dropout=config['variational_dropout'],\n concat_layers=config['concat_rnn_layers'],\n rnn_type=self._RNN_TYPES[config['rnn_type']],\n padding=config['rnn_padding'],\n bidirectional=True,\n )\n\n # RNN question encoder\n self.question_rnn = StackedBRNN(\n input_size=q_input_size,\n hidden_size=config['hidden_size'],\n num_layers=config['num_layers'],\n dropout_rate=config['dropout_rnn'],\n dropout_output=config['dropout_rnn_output'],\n variational_dropout=config['variational_dropout'],\n concat_layers=config['concat_rnn_layers'],\n rnn_type=self._RNN_TYPES[config['rnn_type']],\n padding=config['rnn_padding'],\n bidirectional=True,\n )\n\n # Output sizes of rnn encoders\n doc_hidden_size = 2 * config['hidden_size']\n question_hidden_size = 2 * config['hidden_size']\n if config['concat_rnn_layers']:\n doc_hidden_size *= config['num_layers']\n question_hidden_size *= config['num_layers']\n\n if config['doc_self_attn']:\n self.doc_self_attn = SeqAttnMatch(doc_hidden_size)\n doc_hidden_size = doc_hidden_size + question_hidden_size\n\n # Question merging\n if config['question_merge'] not in ['avg', 'self_attn']:\n raise NotImplementedError('question_merge = %s' % config['question_merge'])\n if config['question_merge'] == 'self_attn':\n self.self_attn = LinearSeqAttn(question_hidden_size)\n\n # Bilinear attention for span start/end\n self.start_attn = BilinearSeqAttn(\n doc_hidden_size,\n question_hidden_size,\n )\n q_rep_size = question_hidden_size + doc_hidden_size if config['span_dependency'] else question_hidden_size\n self.end_attn = BilinearSeqAttn(\n doc_hidden_size,\n q_rep_size,\n )\n\n def forward(self, ex):\n \"\"\"Inputs:\n xq = question word indices (batch, max_q_len)\n xq_mask = question padding mask (batch, max_q_len)\n xd = document word indices (batch, max_d_len)\n xd_f = document word features indices (batch, max_d_len, nfeat)\n xd_mask = document padding mask (batch, max_d_len)\n targets = span targets (batch,)\n \"\"\"\n # Embed both document and question\n xq_emb = self.w_embedding(ex['xq']) # (batch, max_q_len, word_embed)\n xd_emb = self.w_embedding(ex['xd']) # (batch, max_d_len, word_embed)\n\n shared_axes = [2] if self.config['word_dropout'] else []\n xq_emb = dropout(xq_emb, self.config['dropout_emb'], shared_axes=shared_axes, training=self.training)\n xd_emb = dropout(xd_emb, self.config['dropout_emb'], shared_axes=shared_axes, training=self.training)\n xd_mask = ex['xd_mask']\n xq_mask = ex['xq_mask']\n\n\n # Add attention-weighted question representation\n if self.config['use_qemb']:\n xq_weighted_emb = self.qemb_match(xd_emb, xq_emb, xq_mask)\n drnn_input = torch.cat([xd_emb, xq_weighted_emb], 2)\n else:\n drnn_input = xd_emb\n\n if self.config[\"num_features\"] > 0:\n drnn_input = torch.cat([drnn_input, ex['xd_f']], 2)\n\n # Project document and question to the same size as their encoders\n if self.config['resize_rnn_input']:\n drnn_input = F.relu(self.doc_linear(drnn_input))\n xq_emb = F.relu(self.q_linear(xq_emb))\n if self.config['dropout_ff'] > 0:\n drnn_input = F.dropout(drnn_input, training=self.training)\n xq_emb = F.dropout(xq_emb, training=self.training)\n\n # Encode document with RNN\n doc_hiddens = self.doc_rnn(drnn_input, xd_mask) # (batch, max_d_len, hidden_size)\n\n # Document self attention\n if self.config['doc_self_attn']:\n xd_weighted_emb = self.doc_self_attn(doc_hiddens, doc_hiddens, xd_mask)\n doc_hiddens = torch.cat([doc_hiddens, xd_weighted_emb], 2)\n\n # Encode question with RNN + merge hiddens\n question_hiddens = self.question_rnn(xq_emb, xq_mask)\n if self.config['question_merge'] == 'avg':\n q_merge_weights = uniform_weights(question_hiddens, xq_mask)\n elif self.config['question_merge'] == 'self_attn':\n q_merge_weights = self.self_attn(question_hiddens.contiguous(), xq_mask)\n question_hidden = weighted_avg(question_hiddens, q_merge_weights)\n\n # Predict start and end positions\n #始点と終点の予測\n start_scores = self.start_attn(doc_hiddens, question_hidden, xd_mask)\n if self.config['span_dependency']:\n question_hidden = torch.cat([question_hidden, (doc_hiddens * start_scores.exp().unsqueeze(2)).sum(1)], 1)\n end_scores = self.end_attn(doc_hiddens, question_hidden, xd_mask)\n\n return {'score_s': start_scores,\n 'score_e': end_scores,\n 'targets': ex['targets']}\n"
] | [
[
"torch.nn.Linear",
"torch.cat",
"torch.nn.functional.dropout"
]
] |
YNYuan/OpenChem | [
"4364af6d92ae183aac0bea35726d7ae0ee518920"
] | [
"openchem/layers/ipd.py"
] | [
"# modified from https://github.com/tkipf/gae/blob/master/gae/layers.py\n\nimport torch\nimport torch.nn as nn\n\nclass InnerProductDecoder(nn.Module):\n \"\"\"Decoder model layer for link prediction.\"\"\"\n def __init__(self, input_dim, act=nn.functional.sigmoid):\n super(InnerProductDecoder, self).__init__()\n self.act = act\n\n def forward(self, inputs):\n x = inputs.transpose(1,2)\n x = torch.mm(inputs, x)\n x = x.view(-1)\n outputs = self.act(x)\n return outputs"
] | [
[
"torch.mm"
]
] |
TomLXXVI/pypeflow | [
"49e42621180ec3125afa238d3ca56ae9f3a7662a"
] | [
"source_code/pypeflow/utils/pump_curve.py"
] | [
"\"\"\"\n## Pump curve fitting and drawing\n\n- Establish an equation for the pump curve from measured points on the curve in the pump's data sheet\n- Get the coefficients of the 2nd order polynomial describing the pump curve and determined via curve fitting\n- Draw the pump curve in a diagram\n\n\"\"\"\nfrom typing import List, Tuple, Dict, Optional\nimport numpy as np\nimport quantities as qty\nfrom nummath.interpolation import PolyFit\nfrom nummath.graphing2 import LineGraph\n\n\nclass PumpCurve:\n\n def __init__(self, dest_units: Dict[str, str]):\n \"\"\"\n Create *PumpCurve* object.\n\n **Parameters:**\n\n - `dest_units`: (*Dict[str, str]*)<br>\n The measuring units in which the pump curve will be expressed. Keys:\n\n + 'flow_rate'\n + 'pressure'\n\n \"\"\"\n self._meas_points: List[Tuple[qty.VolumeFlowRate, qty.Pressure]] = []\n self._dest_units: Dict[str, str] = dest_units\n self._coefficients: Optional[np.array] = None\n\n def add_measuring_points(self, points: List[Tuple[float, float]], units: Dict[str, str]):\n \"\"\"\n Add some data points taken from the pump curve in the data sheet. This will execute the curve fitting\n algorithm that approaches the pump curve with a 2nd order polynomial.\n\n **Parameters:**\n\n - `points`: (*List[Tuple[float, float]]*)<br>\n List of tuples. The 1st element of the tuple is flow rate, the 2nd element is pressure.\n - `units`: (*Dict[str, str]*)<br>\n Dictionary that contains the measuring units in which the values of the data points are expressed. Keys:\n\n + 'flow_rate'\n + 'pressure'\n\n \"\"\"\n self._meas_points = [\n (qty.VolumeFlowRate(V, units['flow_rate']), qty.Pressure(p, units['pressure'])) for V, p in points\n ]\n self._curve_fitting()\n\n def _curve_fitting(self):\n pf = PolyFit(\n x_data=[V(self._dest_units['flow_rate']) for V, _ in self._meas_points],\n y_data=[p(self._dest_units['pressure']) for _, p in self._meas_points],\n m=2\n )\n self._coefficients = pf.solve()\n\n def get_coefficients(self, units: Optional[Dict[str, str]] = None) -> Optional[List[float]]:\n \"\"\"\n Get the coefficients of the 2nd order polynomial describing the pump curve.\n\n **Parameters:**\n\n - `units`: (*Optional[[Dict[str, str]]*)<br>\n Optional dictionary that contains the measuring units in which the returned coefficients must be expressed.\n Default is None, which means that the coefficients will be returned expressed in the measuring units passed in\n at the instantiation of the *PumpCurve* object. Keys:\n\n + 'flow_rate'\n + 'pressure'\n\n \"\"\"\n if units is not None:\n p_src = qty.Pressure(1.0, self._dest_units['pressure'])\n V_src = qty.VolumeFlowRate(1.0, self._dest_units['flow_rate'])\n p_des = p_src(units['pressure'])\n V_des = V_src(units['flow_rate'])\n else:\n p_des = 1.0\n V_des = 1.0\n a0 = self._coefficients[0] * p_des\n a1 = self._coefficients[1] * (p_des / V_des)\n a2 = self._coefficients[2] * (p_des / V_des ** 2)\n return [a0, a1, a2]\n\n def set_coefficients(self, coeff: Tuple[float, float, float], units: Dict[str, str]):\n \"\"\"\n Set the known coefficients of the 2nd order polynomial describing the pump curve.\n\n **Parameters:**\n\n - `coeff`: (*Tuple[float, float, float]*)<br>\n Tuple of 3 floats: a0, a1 and a2 as in the equation dp_pump = a0 + a1 * V + a2 * V **2\n - `units`: (*Dict[str, str]*)<br>\n Dictionary that contains the measuring units in which the pump coefficients are expressed. Keys:\n\n + 'flow_rate'\n + 'pressure'\n\n \"\"\"\n p_src = qty.Pressure(1.0, units['pressure'])\n V_src = qty.VolumeFlowRate(1.0, units['flow_rate'])\n p_des = p_src(self._dest_units['pressure'])\n V_des = V_src(self._dest_units['flow_rate'])\n a0 = coeff[0] * p_des\n a1 = coeff[1] * (p_des / V_des)\n a2 = coeff[2] * (p_des / V_des ** 2)\n self._coefficients = np.array([a0, a1, a2])\n\n def create_pump_curve(self, V_initial: qty.VolumeFlowRate, V_final: qty.VolumeFlowRate, num: int = 50):\n \"\"\"\n Calculate the pump curve between an initial and final flow rate.\n\n **Parameters:**\n\n - `V_initial`: (*quantities.VolumeFlowRate*) = initial flow rate\n - `V_final`: (*quantities.VolumeFlowRate*) = final flow rate\n - `num`: (*int*) = number of calculation points (default = 50)\n\n **Returns:** (*Tuple[np.array, np.array]*)\n Tuple with 1st element a numpy array of the flow rates and 2nd element a numpy array of the corresponding\n pressures, both expressed in the desired measuring units set at instantiation of the *PumpCurve*-object.\n\n \"\"\"\n V_i = V_initial(self._dest_units['flow_rate'])\n V_f = V_final(self._dest_units['flow_rate'])\n V = np.linspace(V_i, V_f, num, endpoint=True)\n a0 = self._coefficients[0]; a1 = self._coefficients[1]; a2 = self._coefficients[2]\n p = a0 + a1 * V + a2 * V ** 2\n return V, p\n\n def draw_pump_curve(self, V_initial: qty.VolumeFlowRate, V_final: qty.VolumeFlowRate, **kwargs):\n \"\"\"\n Draw the calculated pump curve.\n\n **Parameters:**\n\n - `V_initial`: (*quantities.VolumeFlowRate*) = initial flow rate\n - `V_final`: (*quantities.VolumeFlowRate*) = final flow rate\n - `kwargs`: optional keyword arguments\n + `fig_size`: (*Tuple[float, float]*) = the width and height of the figure in inches\n + `dpi`: (*int*) = dots per inch of the figure\n + `num`: (*int*) = number of calculated points to draw\n + `V_step`: (*quantities.VolumeFlowRate*) = step between ticks on the flow rate axis of the diagram\n + `V_max`: (*quantities.VolumeFlowRate*) = the maximum flow rate shown on the axis\n + `p_step`: (*quantities.Pressure*) = step between ticks on the pressure axis of the diagram\n + `p_max`: (*quantities.Pressure*) = maximum pressure shown on the axis\n + `working_point`: (*Tuple[qty.VolumeFlowRate, qty.Pressure]*) = working point of the pump (shown as a red\n dot on the diagram)\n\n **Returns:** (*nummath.graphing2.LineGraph*)<br>\n Call show() on the returned *LineGraph* object to show the diagram.\n \"\"\"\n if self._coefficients is not None:\n fig_size: Tuple[int, int] = kwargs.get('fig_size', (6, 4))\n dpi: int = kwargs.get('dpi', 96)\n num: int = kwargs.get('num', 50)\n V_step: qty.VolumeFlowRate = kwargs.get('V_step')\n V_max: qty.VolumeFlowRate = kwargs.get('V_max')\n p_step: qty.Pressure = kwargs.get('p_step')\n p_max: qty.Pressure = kwargs.get('p_max')\n working_point: Tuple[qty.VolumeFlowRate, qty.Pressure] = kwargs.get('working_point')\n V, p = self.create_pump_curve(V_initial, V_final, num)\n graph = LineGraph(fig_size=fig_size, dpi=dpi)\n graph.add_dataset(name=\"pump curve\", x1_data=V, y1_data=p)\n if self._meas_points:\n graph.add_dataset(\n name=\"measured points\",\n x1_data=[V(self._dest_units['flow_rate']) for V, _ in self._meas_points],\n y1_data=[p(self._dest_units['pressure']) for _, p in self._meas_points],\n layout={'marker': 'o', 'linestyle': 'None'}\n )\n if working_point:\n graph.add_dataset(\n name=\"working point\",\n x1_data=working_point[0](self._dest_units['flow_rate']),\n y1_data=working_point[1](self._dest_units['pressure']),\n layout={'marker': 'o', 'linestyle': 'None', 'color': 'red'}\n )\n graph.x1.set_title(f'flow rate [{self._dest_units[\"flow_rate\"]}]')\n if V_max is not None and V_step is not None:\n graph.x1.scale(\n lim_down=0.0,\n lim_up=V_max(self._dest_units['flow_rate']),\n step_size=V_step(self._dest_units['flow_rate'])\n )\n graph.y1.set_title(f'pressure [{self._dest_units[\"pressure\"]}]')\n if p_max is not None and p_step is not None:\n graph.y1.scale(\n lim_down=0.0,\n lim_up=p_max(self._dest_units['pressure']),\n step_size=p_step(self._dest_units['pressure'])\n )\n return graph\n\n def pump_head(self, V: qty.VolumeFlowRate) -> qty.Pressure:\n \"\"\"\n Get the pump head (*quantities.Pressure*) if the flow rate (*quantities.VolumeFlowRate*) is given.\n\n \"\"\"\n a0 = self._coefficients[0]\n a1 = self._coefficients[1]\n a2 = self._coefficients[2]\n V = V(self._dest_units['flow_rate'])\n return qty.Pressure(a0 + a1 * V + a2 * V ** 2, self._dest_units['pressure'])\n\n\nif __name__ == '__main__':\n\n pump_curve = PumpCurve(dest_units={'flow_rate': 'L/s', 'pressure': 'bar'})\n pump_curve.add_measuring_points(\n points=[(0.0, 60.0), (2.4, 52.0), (4.2, 48.0), (6.0, 36.0)],\n units={'flow_rate': 'm^3/h', 'pressure': 'm'}\n )\n\n coeff1 = pump_curve.get_coefficients(units={'pressure': 'Pa', 'flow_rate': 'm^3/s'})\n print(coeff1)\n coeff2 = pump_curve.get_coefficients(units={'pressure': 'bar', 'flow_rate': 'L/s'})\n print(coeff2)\n\n graph_ = pump_curve.draw_pump_curve(\n V_initial=qty.VolumeFlowRate(0.0, 'm^3/h'),\n V_final=qty.VolumeFlowRate(7.2, 'm^3/h'),\n fig_size=(10, 8),\n dpi=150,\n num=100,\n V_max=qty.VolumeFlowRate(3.0, 'L/s'),\n V_step=qty.VolumeFlowRate(0.5, 'L/s'),\n p_max=qty.Pressure(8.0, 'bar'),\n p_step=qty.Pressure(2.0, 'bar')\n )\n graph_.show()\n"
] | [
[
"numpy.array",
"numpy.linspace"
]
] |
junaid340/AnomalyDetection-In-SurveillanceVideos | [
"758cb507b8f106eb0d4366c3301ee7be355a40b3"
] | [
"Deploy_Model.py"
] | [
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Thu Apr 2 20:56:50 2020\r\n@author: junaid\r\n\"\"\"\r\nimport cv2\r\nimport Model_Wrapper as mp\r\nfrom tensorflow.keras.models import load_model\r\nfrom PreProcessing_V5 import Fit_Preprocessing, GlobalNormalization, ToJson\r\nfrom PreProcessing_V5 import ReadFileNames\r\nimport numpy as np\r\nimport tensorflow as tf\r\n\r\n\r\nprint('\\nTensorflow GPU installed: '+str(tf.test.is_built_with_cuda()))\r\nprint('Is Tensorflow using GPU: '+str(tf.test.is_gpu_available()))\r\n\r\n\r\ndef WriteInfo(err, text, norm_count, anom_count):\r\n '''\r\n The function to tag the predicted frames.\r\n\r\n Parameters\r\n ----------\r\n err : \r\n Mean Squared Error of that frame.\r\n text : \r\n What to write on the frame.\r\n norm_count :\r\n Count of normal frames.\r\n anom_count :\r\n Count of anomalous frames.\r\n\r\n Returns\r\n -------\r\n None.\r\n\r\n '''\r\n mp.PrintInline('{4}, Frame Status: {0}, Normal Frame Count: {1}/{2}, Anomaly Frame Count {3}/{2}'.format(text, norm_count, norm_count+anom_count, anom_count, err))\r\n\r\ndef get_model(model_path):\r\n '''\r\n A function to load the saved model.\r\n\r\n Parameters\r\n ----------\r\n model_path : \r\n Location where the trained model is saved.\r\n\r\n Returns\r\n -------\r\n model : \r\n Trained weights of the model.\r\n\r\n '''\r\n print('\\n\\n------- Loading Model: {0} ! -------'.format(model_path.split('/')[-1]))\r\n print('\\n--------------- This may take a while! ---------------\\n\\n')\r\n model=load_model(model_path)\r\n print('\\n\\n------- Model Loaded! {0} ! -------\\n\\n'.format(model_path.split('/')[-1]))\r\n return model\r\n\r\ndef RealTimeDetection(model, threshold, serve_type='real-time', vid_path=None, verbose=True):\r\n '''\r\n A function that will implement the model in real-time i.e you'll pass a video to the model\r\n and while the video is running the model will be predicting it.\r\n\r\n Parameters\r\n ----------\r\n model : \r\n Which model to load or use for implementation.\r\n threshold : \r\n Threshold for distinguishing anomalous frames from normal frames.\r\n serve_type : optional\r\n How do you want to implement the model 'real-time', 'video', 'frames' or 'numpy'.\r\n The default is 'real-time'.\r\n vid_path : optional\r\n Video path for the testing video. The default is None.\r\n verbose : optional\r\n An argument to report more information about the operation in the programe.The default is True.\r\n\r\n Raises\r\n ------\r\n TypeError\r\n If the serving type is set to video, then you must provide the video path.\r\n EOFError\r\n When the video is completed i.e time length is completed it ends by giving this End Of File error.\r\n\r\n Returns\r\n -------\r\n None.\r\n\r\n '''\r\n if serve_type=='real-time':\r\n cap=cv2.VideoCapture(0)\r\n elif serve_type=='video':\r\n if vid_path==None:\r\n raise TypeError('Value of `vid_path` argument cannot be `None`, when `serve_type` value is `video`. Provide valid path of `str` datatype.')\r\n cap=cv2.VideoCapture(vid_path)\r\n \r\n _,frame=cap.read()\r\n shape = np.shape(frame)\r\n ret=True\r\n norm_count = 0\r\n anom_count = 0\r\n test_history = {'Serving Type':serve_type, 'Loss':[], 'Normal Frames': [], \r\n 'Anomaly Frames':[], 'Total Frames':[]}\r\n print('\\n\\n------- Press q to exit the Real Time Detection! -------\\n')\r\n while(cap.isOpened()):\r\n img_lst=[]\r\n v_frames = np.zeros(shape=(10, shape[0], shape[1], shape[2]), dtype=np.uint8)\r\n for i in range(10):\r\n ret,frame=cap.read()\r\n if (ret != True):\r\n cv2.destroyAllWindows()\r\n raise EOFError('The Video is Completed Succefully!')\r\n #copy the orignal frame for display.\r\n v_frames[i]=frame\r\n gray = mp.ImgProcess(frame, shape=(227,227))\r\n img_lst.append(gray)\r\n img_arr = mp.Img_LstArr(img_lst, re_shape=(227, 227, 10))\r\n #making prediction\r\n pred = model.predict(img_arr)\r\n #computing error\r\n loss = mp.MSE(img_arr, pred)\r\n err = 'Loss: {0:.5f}'.format(loss)\r\n if ret==True:\r\n test_history['Loss'].append(loss); test_history['Normal Frames'].append(norm_count)\r\n test_history['Anomaly Frames'].append(anom_count)\r\n test_history['Total Frames'].append(norm_count+anom_count)\r\n ToJson(test_history, name='Test History.json')\r\n if loss>threshold:\r\n anom_count += 10\r\n text='Anomalies Detected'\r\n for j in range(len(v_frames)):\r\n mp.ShowVideo(cap, v_frames[j], text, fill = True)\r\n if verbose:\r\n WriteInfo(err, text, norm_count, anom_count)\r\n else:\r\n text='Normal'\r\n norm_count += 10\r\n for j in range(len(v_frames)):\r\n mp.ShowVideo(cap, v_frames[j], text, fill = False)\r\n if verbose:\r\n WriteInfo(err, text, norm_count, anom_count)\r\n\r\n\r\n\r\ndef StaticServing(path, model, threshold, frames_ext, serve_type='frames', verbose=True):\r\n '''\r\n This function implements the model on the frames i.e UCSD dataset, it predicts the model\r\n and displays them one by one so it seems to be a video, but in reality it is just \r\n displaying the predicted frames.\r\n\r\n Parameters\r\n ----------\r\n path : \r\n Path for the testing dataset.\r\n model : \r\n Which model to load.\r\n threshold : \r\n Threshold for distinguishing anomalous frames from normal frames.\r\n frames_ext : \r\n Extension of the frames.\r\n serve_type : optional\r\n How to serve the model. The default is 'frames'.\r\n verbose : optional\r\n An argument to report more information about the operation in the programe.The default is True.\r\n\r\n Returns\r\n -------\r\n test_history : \r\n A JASON file containing complete history of the testing. It consists of all MSE's of \r\n all the frames and their predicted results.\r\n\r\n '''\r\n if serve_type=='frames':\r\n onlyfiles, _, _ = ReadFileNames(path, frames_ext)\r\n all_files = mp.ListCopy(onlyfiles)\r\n num = 10\r\n ten_list = np.reshape(all_files, (len(all_files)//num, num))\r\n img_lst = Fit_Preprocessing(path, frames_ext)\r\n X_test = GlobalNormalization(img_lst, save_data=False) \r\n elif serve_type=='npy':\r\n X_test = np.load(path)\r\n \r\n X_test = mp.PrepareData(X_test)\r\n norm_count = 0\r\n anom_count = 0\r\n test_history = {'Serving Type':serve_type, 'Loss':[], 'Normal Frames': [], \r\n 'Anomaly Frames':[], 'Total Frames':[]}\r\n print('\\n\\t------------- Now Serving will begin! -------------\\n\\n')\r\n for number, bunch in enumerate(X_test):\r\n #Reshaping batch to 5 dimensions\r\n batch = np.expand_dims(bunch,axis=0)\r\n pred_batch = model.predict(batch)\r\n #computing loss\r\n loss = mp.MSE(batch, pred_batch)\r\n err = 'Loss: {0:.5f}'.format(loss)\r\n test_history['Loss'].append(loss); test_history['Normal Frames'].append(norm_count)\r\n test_history['Anomaly Frames'].append(anom_count)\r\n test_history['Total Frames'].append(norm_count+anom_count)\r\n ToJson(test_history, name='Test History.json')\r\n if loss>threshold:\r\n anom_count += 10\r\n text='Anomalies Detected'\r\n if serve_type=='frames':\r\n for j in range(len(ten_list[number])):\r\n v_frame = cv2.imread(ten_list[number][j])\r\n cap=None\r\n mp.ShowVideo(cap, v_frame, text, fill = True)\r\n if verbose:\r\n WriteInfo(err, text, norm_count, anom_count)\r\n else:\r\n text='Normal'\r\n norm_count += 10\r\n if serve_type=='frames':\r\n for j in range(len(ten_list[number])):\r\n v_frame = cv2.imread(ten_list[number][j])\r\n cap=None\r\n mp.ShowVideo(cap, v_frame, text, fill = False)\r\n if verbose:\r\n WriteInfo(err, text, norm_count, anom_count)\r\n print('\\n\\t------------- Serving is Completed! -------------\\n\\n')\r\n return test_history\r\n\r\ndef DeploySystem(serve_type, model_path, preset_threshold=True, data_model=None, verbose=True, path=None, frames_ext=None, threshold=None, config_gpu=False):\r\n '''\r\n A function to decide, how to implement the model.\r\n\r\n Parameters\r\n ----------\r\n serve_type : \r\n An integer which tells the function to acitvate specific serving type.\r\n model_path : \r\n Location for the saved model.\r\n preset_threshold : optional\r\n A preset threshold for the prediction. The default is True.\r\n data_model : optional\r\n Tells which data's model is being used i.e UCSD or Avenue. The default is None.\r\n verbose : optional\r\n An argument to report more information about the operation in the programe. The default is True.\r\n path : optional\r\n Path to read the test data. The default is None.\r\n frames_ext : optional\r\n Defining the extension of the frames. The default is None.\r\n threshold : optional\r\n Threshold for distinguishing anomalous frames from normal frames. The default is None.\r\n config_gpu : optional\r\n Configures the GPU of the system. The default is False.\r\n\r\n Raises\r\n ------\r\n TypeError\r\n While 'preset_threshold' is set to True, you must pass a value to 'threshold'.\r\n ValueError\r\n As the model is trained on 2 data sets, UCSD and Avenue, therefore it should either of them.\r\n\r\n Returns\r\n -------\r\n test_hist : \r\n A JASON file containing complete history of the testing. It consists of all MSE's of \r\n all the frames and their predicted results.\r\n \r\n '''\r\n serving_types = ['real-time', 'video', 'frames', 'npy']\r\n if preset_threshold:\r\n if threshold is not None:\r\n raise TypeError('Invalid value given to argument `threshold`, its value must be None when `preset_threshold` argument is set to True.')\r\n if data_model=='UCSD':\r\n threshold=0.00026\r\n elif data_model=='Avenue':\r\n threshold=0.00040\r\n else:\r\n raise ValueError('Invalid value given to the Argument `data_model`, it can be either `UCSD` or `Avenue`!')\r\n else:\r\n if threshold is None:\r\n raise TypeError('None value given to argument `threshold`, it cannot be None when `preset_threshold` argument is set to False, provide a value of `float` datype or set the `preset_threshold` argument to True, to use Preset Values of Threshold.')\r\n if serve_type!='real-time' and serve_type != None:\r\n if path is None:\r\n raise TypeError('None value given to argument `path`, it cannot be None when value of `serve_type` is other than None.')\r\n if config_gpu:\r\n #Setting up the GPU to avoid VRAM and other conflicts.\r\n #For refernce visit: https://github.com/irdanish11/AnomalyEventDetection/issues/1\r\n mp.TF_GPUsetup()\r\n #loading the model\r\n model = get_model(model_path)\r\n ####################### Different Serving Techinques ######################\r\n \r\n #Serve the Anomaly Detection from the WebCam or any video device that is attached.\r\n if serve_type=='real-time':\r\n RealTimeDetection(model, threshold, serve_type, verbose=verbose)\r\n test_hist = None\r\n #Serve the Anomaly Detection from the given video.\r\n elif serve_type=='video':\r\n RealTimeDetection(model, threshold, serve_type, vid_path=path, verbose=verbose)\r\n test_hist = None\r\n #Serve the Anomaly Detection from the directory which contain frames, the Hirerachy of \r\n #directories must be like this: <path>/*Directories/Here all the images\r\n #The path you provide must contain a further directory or directories and in those directories\r\n #should have the frames.\r\n elif serve_type=='frames':\r\n test_hist = StaticServing(path, model, threshold, frames_ext, serve_type, verbose=verbose)\r\n ##Serve the Anomaly Detection from the .npy file.\r\n elif serve_type=='npy':\r\n test_hist = StaticServing(path, model, threshold, frames_ext, serve_type, verbose=verbose)\r\n else:\r\n raise ValueError('Invalid value given to the `serve_type` argument. Possible values: {0}'.format(serving_types))\r\n return test_hist\r\n\r\n\r\n\r\nif __name__=='__main__':\r\n \r\n #model_path = 'checkpoints/Train_UCSDped1_Model.h5'\r\n model_path = 'checkpoints/Train_AvenueDataset_Model.h5'\r\n \r\n vid_path = './Avenue_Dataset/testing_videos/05.avi' #5,9\r\n \r\n frames_ext='.tif'\r\n frames_dir='Datasets/UCSDped1/Test'\r\n \r\n npy_file='./Test_Data/Test_AvenueDataset.npy'\r\n \r\n #possible serving types\r\n #0-->real time\r\n #1-->video\r\n #2-->frames\r\n #3-->numpy array\r\n serving_types = ['real-time', 'video', 'frames', 'npy']\r\n #Serving of Model\r\n serve_type = serving_types[1]\r\n test_hist = DeploySystem(serve_type, model_path, preset_threshold=True, data_model='Avenue', verbose=True, \r\n path=vid_path, frames_ext=frames_ext, threshold=None, config_gpu=False)\r\n "
] | [
[
"numpy.load",
"numpy.zeros",
"tensorflow.keras.models.load_model",
"tensorflow.test.is_built_with_cuda",
"numpy.expand_dims",
"numpy.shape",
"tensorflow.test.is_gpu_available"
]
] |
utsav-akhaury/Computational-Electromagnetics-FDTD-Analysis | [
"add2df141ba9c6414b19ac55d24c4251bbd05430"
] | [
"homog_gau_abc.py"
] | [
"\r\n#------------------ Gaussian pulse propagation in a homogeneous medium terminated with Absorbing Boundary Condition (ABC)\r\n\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n#----- Medium ----------\r\nlength = 2 \r\neps0 = 8.854e-12\r\nmeu0 = 4*np.pi*1e-7\r\nepsr = 1\r\nmeur = 1\r\neps = eps0*epsr\r\nmeu = meu0*meur\r\n\r\n#---- Signal -----------\r\nc = 3e8\r\nv = c/np.sqrt(epsr*meur)\r\nfreq = 3e9\r\nlamda = v/freq\r\n\r\n#------ Cell length and time step---------\r\ndz = lamda/10\r\ndt = dz/v\r\nN_cells = int(length/dz)\r\nMid_cell = int(N_cells/2)\r\n\r\n#------ Multiplying constants --------\r\nconst_e = dt/(eps*dz)\r\nconst_h = dt/(meu*dz)\r\n\r\n#------- Initialise E and H arrays ------------\r\nex = np.zeros(N_cells)\r\nhy = np.zeros(N_cells)\r\n\r\n#------ Gaussian pulse ------------\r\nTs = 10*dt # pulse width\r\nt0 = 3*Ts # delay\r\nN_steps = 200 # maximum iteration steps\r\n\r\n#----------------------------------\r\nex_past = np.zeros(N_cells)\r\nconst_abc = (v*dt - dz)/(v*dt + dz)\r\n\r\n#************** Iteration loop ****************\r\n\r\nfor n in range (N_steps): \r\n time = n*dt \r\n \r\n #------- Gaussian pulse launched in the middle cell -----------\r\n pulse = (np.exp(-np.power(((time-t0)/Ts),2)))/dz \r\n ex[Mid_cell-1] = pulse \r\n \r\n #------------------------ compute H -------------------------\r\n k = np.linspace(0, N_cells-2, N_cells-1, dtype = int)\r\n hy[k] = hy[k]-const_h*(ex[k+1]-ex[k])\r\n \r\n #------------------------ compute E -------------------------\r\n k = np.linspace(1, N_cells-2, N_cells-2, dtype = int)\r\n ex[k] = ex[k]-const_e*(hy[k]-hy[k-1]) \r\n \r\n #------------------------- ABC ------------------------------\r\n ex[0] = ex_past[1] + const_abc*(ex[1]-ex[0])\r\n ex[N_cells-1] = ex_past[N_cells-2] + const_abc*(ex[N_cells-2]-ex[N_cells-1])\r\n ex_past = np.copy(ex)\r\n \r\n #------------------------ plot ------------------------------\r\n plt.plot(np.linspace(1, N_cells, N_cells, dtype = int),ex)\r\n plt.xlim(0,200)\r\n plt.ylim((-150,150))\r\n plt.grid()\r\n plt.show()\r\n"
] | [
[
"numpy.zeros",
"matplotlib.pyplot.grid",
"numpy.copy",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.show",
"numpy.power",
"matplotlib.pyplot.ylim",
"numpy.sqrt",
"numpy.linspace"
]
] |
lebrice/avalanche | [
"fe7e1e664ab20697343495fbe1328a20215feffb"
] | [
"avalanche/benchmarks/datasets/core50/core50.py"
] | [
"################################################################################\n# Copyright (c) 2021 ContinualAI. #\n# Copyrights licensed under the MIT License. #\n# See the accompanying LICENSE file for terms. #\n# #\n# Date: 10-10-2020 #\n# Author: Vincenzo Lomonaco #\n# E-mail: [email protected] #\n# Website: www.continualai.org #\n################################################################################\n\n\"\"\" CORe50 Pytorch Dataset \"\"\"\n\nimport os\nimport logging\nfrom torch.utils.data.dataset import Dataset\nfrom torchvision.transforms import ToTensor\nfrom PIL import Image\nimport pickle as pkl\nfrom os.path import expanduser\nfrom .core50_data import CORE50_DATA\n\n\ndef pil_loader(path):\n \"\"\" Load an Image with PIL \"\"\"\n # open path as file to avoid ResourceWarning\n # (https://github.com/python-pillow/Pillow/issues/835)\n with open(path, 'rb') as f:\n img = Image.open(f)\n return img.convert('RGB')\n\n\nclass CORe50(Dataset):\n \"\"\" CORe50 Pytorch Dataset \"\"\"\n\n def __init__(self, root=expanduser(\"~\")+\"/.avalanche/data/core50/\",\n train=True, transform=ToTensor(), target_transform=None,\n loader=pil_loader, download=True):\n\n self.train = train # training set or test set\n self.transform = transform\n self.target_transform = target_transform\n self.root = root\n self.loader = loader\n self.log = logging.getLogger(\"avalanche\")\n\n # any scenario and run is good here since we want just to load the\n # train images and targets with no particular order\n scen = 'ni'\n run = 0\n nbatch = 8\n\n if download:\n self.core_data = CORE50_DATA(data_folder=root)\n\n self.log.info(\"Loading paths...\")\n with open(os.path.join(root, 'paths.pkl'), 'rb') as f:\n self.train_test_paths = pkl.load(f)\n\n self.log.info(\"Loading labels...\")\n with open(os.path.join(root, 'labels.pkl'), 'rb') as f:\n self.all_targets = pkl.load(f)\n self.train_test_targets = []\n for i in range(nbatch + 1):\n self.train_test_targets += self.all_targets[scen][run][i]\n\n self.log.info(\"Loading LUP...\")\n with open(os.path.join(root, 'LUP.pkl'), 'rb') as f:\n self.LUP = pkl.load(f)\n\n self.idx_list = []\n if train:\n for i in range(nbatch + 1):\n self.idx_list += self.LUP[scen][run][i]\n else:\n self.idx_list = self.LUP[scen][run][-1]\n\n self.paths = []\n self.targets = []\n\n for idx in self.idx_list:\n self.paths.append(self.train_test_paths[idx])\n self.targets.append(self.train_test_targets[idx])\n\n def __getitem__(self, index):\n \"\"\"\n Args:\n index (int): Index\n\n Returns:\n tuple: (sample, target) where target is class_index of the target\n class.\n \"\"\"\n\n target = self.targets[index]\n img = self.loader(\n os.path.join(\n self.root, \"core50_128x128\", self.paths[index]\n )\n )\n if self.transform is not None:\n img = self.transform(img)\n if self.target_transform is not None:\n target = self.target_transform(target)\n\n return img, target\n\n def __len__(self):\n return len(self.targets)\n\n\nif __name__ == \"__main__\":\n\n # this litte example script can be used to visualize the first image\n # leaded from the dataset.\n from torch.utils.data.dataloader import DataLoader\n import matplotlib.pyplot as plt\n from torchvision import transforms\n import torch\n\n train_data = CORe50()\n test_data = CORe50(train=False)\n print(\"train size: \", len(train_data))\n print(\"Test size: \", len(test_data))\n dataloader = DataLoader(train_data, batch_size=1)\n\n for batch_data in dataloader:\n x, y = batch_data\n plt.imshow(\n transforms.ToPILImage()(torch.squeeze(x))\n )\n plt.show()\n print(x.size())\n print(len(y))\n break\n\n\n__all__ = [\n 'CORe50'\n]\n"
] | [
[
"torch.utils.data.dataloader.DataLoader",
"matplotlib.pyplot.show",
"torch.squeeze"
]
] |
LTHODAVDOPL/tensorflow | [
"73083d29afe770870742a9d19555686886e76f6d"
] | [
"tensorflow/python/framework/function_test.py"
] | [
"# Copyright 2015 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 functions.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport re\nimport sys\nimport time\n\nimport numpy as np\n\nfrom tensorflow.core.framework import function_pb2\nfrom tensorflow.core.protobuf import config_pb2\nfrom tensorflow.core.protobuf import rewriter_config_pb2\nfrom tensorflow.python.client import session\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import errors_impl\nfrom tensorflow.python.framework import function\nfrom tensorflow.python.framework import graph_to_function_def\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.framework.errors import InvalidArgumentError\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import control_flow_ops\nfrom tensorflow.python.ops import functional_ops\nfrom tensorflow.python.ops import gen_logging_ops\nfrom tensorflow.python.ops import gradients_impl\nfrom tensorflow.python.ops import init_ops\nfrom tensorflow.python.ops import linalg_ops\nfrom tensorflow.python.ops import logging_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import nn_ops\nfrom tensorflow.python.ops import random_ops\nfrom tensorflow.python.ops import variable_scope\nfrom tensorflow.python.ops import variables\nfrom tensorflow.python.platform import test\nfrom tensorflow.python.platform import tf_logging\n\n\ndef _OptimizerOptions():\n for cse in [False, True]:\n for inline in [False, True]:\n for cfold in [False, True]:\n cfg = config_pb2.ConfigProto(\n graph_options=config_pb2.GraphOptions(\n optimizer_options=config_pb2.OptimizerOptions(\n opt_level=config_pb2.OptimizerOptions.L0,\n do_common_subexpression_elimination=cse,\n do_function_inlining=inline,\n do_constant_folding=cfold)))\n if cse:\n cfg.graph_options.rewrite_options.arithmetic_optimization = (\n rewriter_config_pb2.RewriterConfig.ON)\n else:\n cfg.graph_options.rewrite_options.arithmetic_optimization = (\n rewriter_config_pb2.RewriterConfig.OFF)\n if inline:\n cfg.graph_options.rewrite_options.function_optimization = (\n rewriter_config_pb2.RewriterConfig.ON)\n else:\n cfg.graph_options.rewrite_options.function_optimization = (\n rewriter_config_pb2.RewriterConfig.OFF)\n if cfold:\n cfg.graph_options.rewrite_options.constant_folding = (\n rewriter_config_pb2.RewriterConfig.ON)\n else:\n cfg.graph_options.rewrite_options.constant_folding = (\n rewriter_config_pb2.RewriterConfig.OFF)\n yield cfg\n\n\n@test_util.with_c_shapes\nclass FunctionTest(test.TestCase):\n \"\"\"Test methods for verifying Function support.\n\n These test methods are used as mix-ins in two test cases: with\n and without C API support.\n \"\"\"\n\n def testIdentity(self):\n\n @function.Defun(dtypes.float32, func_name=\"MyIdentity\")\n def MyIdentityFunc(a):\n return a\n\n with ops.Graph().as_default():\n call = MyIdentityFunc([18.0])\n self.assertEqual(\"MyIdentity\", call.op.name)\n with session.Session() as sess:\n self.assertAllEqual([18.0], sess.run(call))\n\n def testIdentityImplicitDeref(self):\n\n @function.Defun(dtypes.float32, func_name=\"MyIdentity\")\n def MyIdentityFunc(a):\n return a\n\n with ops.Graph().as_default():\n var = variables.Variable([18.0])\n call = MyIdentityFunc(var._ref()) # pylint: disable=protected-access\n self.assertEqual(\"MyIdentity\", call.op.name)\n for cfg in _OptimizerOptions():\n with session.Session(config=cfg) as sess:\n sess.run(var.initializer)\n self.assertAllEqual([18.0], sess.run(call))\n\n def testIdentityOutputName(self):\n\n @function.Defun(\n dtypes.float32, func_name=\"MyIdentity\", out_names=[\"my_result_name\"])\n def MyIdentityFunc(a):\n return a\n\n with ops.Graph().as_default():\n call = MyIdentityFunc([18.0])\n self.assertEqual(\"MyIdentity\", call.op.name)\n with session.Session() as sess:\n self.assertAllEqual([18.0], sess.run(call))\n\n def testTooManyOutputNames(self):\n\n @function.Defun(\n dtypes.float32,\n func_name=\"MyIdentity\",\n out_names=[\"my_result1\", \"my_result2\"])\n def MyIdentityFunc(a):\n return a\n\n with ops.Graph().as_default():\n with self.assertRaisesRegexp(\n errors_impl.InvalidArgumentError,\n (r\"output names must be either empty or equal in size to outputs. \"\n \"output names size = 2 outputs size = 1\")):\n MyIdentityFunc([18.0])\n\n def testDefineFunction2Args(self):\n\n @function.Defun(dtypes.float32, dtypes.float32, func_name=\"APlus2B\")\n def APlus2B(a, b):\n return a + b * 2\n\n with ops.Graph().as_default():\n call = APlus2B([1.0], [2.0])\n self.assertEqual(\"APlus2B\", call.op.name)\n with session.Session() as sess:\n self.assertAllEqual([5.0], sess.run(call))\n\n def testFunctionWithNoOutput(self):\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def APlus2B(a, b):\n c = a + b * 2 # Create some ops to have nodes in the body\n print(c) # Using 'print' to make lint happy\n\n with ops.Graph().as_default():\n # Call function. There should be no exceptions.\n APlus2B([1.0], [2.0])\n\n def testDefineFunction2ArgsOutputName(self):\n\n @function.Defun(\n dtypes.float32,\n dtypes.float32,\n func_name=\"APlus2B\",\n out_names=[\"my_result_name\"])\n def APlus2B(a, b):\n return a + b * 2\n\n # APlus2B is stateless.\n self.assertEqual([], APlus2B.stateful_ops)\n with ops.Graph().as_default():\n call = APlus2B([1.0], [2.0])\n self.assertEqual(\"APlus2B\", call.op.name)\n with session.Session() as sess:\n self.assertAllEqual([5.0], sess.run(call))\n\n def testDefineFunctionDuplicateOutputs(self):\n\n @function.Defun(dtypes.float32, func_name=\"Duplicate\")\n def Duplicate(a):\n b = a + 1.0\n return b, b\n\n g = ops.Graph()\n with g.as_default():\n Duplicate([3.0])\n func_sig = g.as_graph_def().library.function[0].signature\n # The names given to both outputs should be different\n # even though the same tensor is emitted to both.\n out_names = [a.name for a in func_sig.output_arg]\n self.assertEqual(2, len(out_names))\n self.assertNotEqual(out_names[0], out_names[1])\n\n def testGradientFunc(self):\n\n @function.Defun(dtypes.float32, func_name=\"XSquarePlusOneFn\")\n def XSquarePlusOne(x):\n return x * x + 1.0\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def XSquarePlusOneGrad(x, dy):\n dx = functional_ops.symbolic_gradient(\n input=[x, dy], Tout=[dtypes.float32], f=\"XSquarePlusOneFn\", name=\"dx\")\n return dx\n\n g = ops.Graph()\n with g.as_default():\n call_f = XSquarePlusOne([2.0])\n call_g = XSquarePlusOneGrad([2.0], [0.1])\n\n with session.Session() as sess:\n self.assertAllClose([5.0], sess.run(call_f))\n self.assertAllClose([0.4], sess.run(call_g))\n\n def testTanhSymGrad(self):\n\n @function.Defun(dtypes.float32)\n def Forward(x):\n return math_ops.reduce_sum(math_ops.tanh(x))\n\n g = ops.Graph()\n with g.as_default():\n x = array_ops.placeholder(dtypes.float32)\n y = Forward(x)\n dx = gradients_impl.gradients([y], [x])\n\n inp = np.array([-1, 1, 2, -2], dtype=np.float32)\n feed = {x: inp}\n cfg = config_pb2.ConfigProto(\n graph_options=config_pb2.GraphOptions(\n optimizer_options=config_pb2.OptimizerOptions(\n opt_level=config_pb2.OptimizerOptions.L1,\n do_function_inlining=True)))\n with session.Session(graph=g, config=cfg) as sess:\n out, = sess.run(dx, feed)\n self.assertAllClose(1 - np.square(np.tanh(inp)), out)\n\n def testCustomGradient(self):\n dtype = dtypes.float32\n\n @function.Defun(dtype, dtype, dtype)\n def XentLossGrad(logits, labels, dloss):\n dlogits = array_ops.reshape(dloss, [-1, 1]) * (\n nn_ops.softmax(logits) - labels)\n dlabels = array_ops.zeros_like(labels)\n # Takes exp(dlogits) to differentiate it from the \"correct\" gradient.\n return math_ops.exp(dlogits), dlabels\n\n @function.Defun(dtype, dtype, grad_func=XentLossGrad)\n def XentLoss(logits, labels):\n return math_ops.reduce_sum(labels * math_ops.log(nn_ops.softmax(logits)),\n 1)\n\n g = ops.Graph()\n with g.as_default():\n logits = array_ops.placeholder(dtype)\n labels = array_ops.placeholder(dtype)\n loss = XentLoss(logits, labels)\n dlogits = gradients_impl.gradients([loss], [logits])\n\n x = np.random.uniform(-10., 10., size=(4, 9)).astype(np.float32)\n prob = np.exp(x) / np.sum(np.exp(x), 1, keepdims=1)\n y = np.random.uniform(-10., 10., size=(4, 9)).astype(np.float32)\n for cfg in _OptimizerOptions():\n tf_logging.info(\"cfg = %s\", cfg)\n with session.Session(graph=g, config=cfg) as sess:\n out, = sess.run(dlogits, {logits: x, labels: y})\n self.assertAllClose(out, np.exp(prob - y))\n\n def testCustomGradientError(self):\n dtype = dtypes.float32\n\n @function.Defun(dtype, dtype, dtype)\n def Grad(x, dy, dz):\n # Should have returned 1 result.\n return x, dy + dz\n\n @function.Defun(dtype, grad_func=Grad)\n def Forward(x):\n return x, x\n\n g = ops.Graph()\n with g.as_default():\n inp = array_ops.placeholder(dtype)\n out = math_ops.add_n(Forward(inp))\n dinp = gradients_impl.gradients(out, [inp])\n\n x = np.random.uniform(-10., 10., size=(4, 9)).astype(np.float32)\n with session.Session(graph=g) as sess:\n with self.assertRaisesRegexp(\n errors_impl.InvalidArgumentError,\n \"SymGrad expects to return 1.*but get 2.*instead\"):\n _ = sess.run(dinp, {inp: x})\n\n def testSymGradShape(self):\n g = ops.Graph()\n with g.as_default():\n x = array_ops.placeholder(dtypes.float32, [25, 4])\n y = array_ops.placeholder(dtypes.float32, [200, 100])\n dz = array_ops.placeholder(dtypes.float32, [1])\n # We assume Foo is a function of (x, y) -> (z) Then, Foo's\n # gradient function is (x, y, dz) -> (dx, dy). dx's shape\n # should be the same as x's; and dy's shape should be the same\n # as y's.\n dx, dy = functional_ops.symbolic_gradient(\n input=[x, y, dz], Tout=[dtypes.float32] * 2, f=\"Foo\")\n self.assertEqual(x.get_shape(), dx.get_shape())\n self.assertEqual(y.get_shape(), dy.get_shape())\n\n def testSymGradAttr(self):\n\n @function.Defun(noinline=True)\n def Foo(x):\n return x * 2\n\n self.assertTrue(\n Foo.instantiate([dtypes.float32]).definition.attr[\"_noinline\"].b)\n\n g = ops.Graph()\n with g.as_default():\n x = constant_op.constant(3.0)\n y = Foo(x)\n dx, = gradients_impl.gradients(y, [x])\n\n cfg = config_pb2.ConfigProto(\n graph_options=config_pb2.GraphOptions(\n optimizer_options=config_pb2.OptimizerOptions(\n opt_level=config_pb2.OptimizerOptions.L0,\n do_common_subexpression_elimination=True,\n do_function_inlining=True,\n do_constant_folding=True)))\n\n with self.session(graph=g, config=cfg):\n self.assertAllClose(y.eval(), 6.)\n self.assertAllClose(dx.eval(), 2.)\n\n def _testZNoDepOnY(self, use_const_grad_ys):\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def Foo(x, y): # pylint: disable=unused-argument\n return x * 2\n\n with ops.Graph().as_default():\n # z = Foo(x, y). z doe\n x = constant_op.constant(1.0)\n y = constant_op.constant(2.0)\n z = Foo(x, y)\n if use_const_grad_ys:\n dx, dy = gradients_impl.gradients([z], [x, y], grad_ys=[1.0])\n else:\n dx, dy = gradients_impl.gradients([z], [x, y])\n with session.Session() as sess:\n dx_val, dy_val = sess.run([dx, dy])\n self.assertEqual([2.0], dx_val)\n self.assertEqual([0.0], dy_val)\n\n def testZNoDepOnY(self):\n self._testZNoDepOnY(False)\n\n def testZNoDepOnYConstGradYs(self):\n # Tests for constant folding of grad_ys\n self._testZNoDepOnY(True)\n\n def testDefineFunctionNoArgs(self):\n\n @function.Defun(func_name=\"AConstant\")\n def AConstant():\n return constant_op.constant([42])\n\n with ops.Graph().as_default():\n\n call = AConstant()\n self.assertEqual(\"AConstant\", call.op.name)\n with session.Session() as sess:\n self.assertAllEqual([42], sess.run(call))\n\n def testDefineFunctionNames(self):\n\n @function.Defun(dtypes.float32, func_name=\"Foo\")\n def Foo(a):\n return a + 1\n\n with ops.Graph().as_default():\n call1 = Foo([1.0])\n self.assertEqual(\"Foo\", call1.op.name)\n call2 = Foo([1.0])\n self.assertEqual(\"Foo_1\", call2.op.name)\n # pylint: disable=unexpected-keyword-arg\n call3 = Foo([1.0], name=\"mine\")\n self.assertEqual(\"mine\", call3.op.name)\n with ops.name_scope(\"my\"):\n call4 = Foo([1.0], name=\"precious\")\n self.assertEqual(\"my/precious\", call4.op.name)\n\n def testNoOp(self):\n\n @function.Defun(dtypes.float32)\n def Foo(x):\n y = logging_ops.Print(x, [], \"Hello\")\n with ops.control_dependencies([y]):\n z = control_flow_ops.no_op()\n with ops.control_dependencies([z]):\n return x * 2\n\n with ops.Graph().as_default(), self.cached_session():\n z = Foo(constant_op.constant(3.0))\n self.assertAllEqual(z.eval(), 6.0)\n\n def testAssertOp(self):\n\n @function.Defun(dtypes.float32)\n def Foo(x):\n check = gen_logging_ops._assert(math_ops.greater(x, 0), [x])\n with ops.control_dependencies([check]):\n return x * 2\n\n # Foo contains a stateful op (Assert).\n self.assertEqual([(\"Assert\", \"Assert\")], Foo.stateful_ops)\n g = ops.Graph()\n with g.as_default(), self.cached_session():\n self.assertAllEqual(Foo(constant_op.constant(3.0)).eval(), 6.0)\n with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,\n \"assertion failed.*-3\"):\n self.assertAllEqual(Foo(constant_op.constant(-3.0)).eval(), 6.0)\n\n def testAssertWrapper(self):\n\n @function.Defun(dtypes.float32)\n def MyFn(x):\n with ops.control_dependencies(\n [control_flow_ops.Assert(math_ops.less_equal(x, 10.0), [x])]):\n return array_ops.identity(x)\n\n with self.cached_session():\n self.assertEqual(1.0, MyFn(1.0).eval())\n with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,\n \"assertion\"):\n _ = MyFn(100.0).eval()\n\n def testWhileLoopCallsFunc(self):\n with self.test_session(use_gpu=True) as sess:\n\n @function.Defun(dtypes.float32)\n def Times2(x):\n constant_two = constant_op.constant(2, dtypes.int32)\n two_on_gpu = math_ops.cast(constant_two, dtypes.float32)\n return x * two_on_gpu\n\n def Body(x):\n x2 = Times2(x)\n x2.set_shape([])\n return x2\n\n loop = control_flow_ops.while_loop(lambda x: x < 1e5, Body, [1.0])\n\n ans = sess.run(loop)\n self.assertAllClose(ans, 131072.)\n\n def testControlFlowStrictness(self):\n \"\"\"Inlined functions must not execute in a untaken control flow branch.\"\"\"\n\n @function.Defun(dtypes.int32)\n def AssertFail(x):\n # Assertion that always fails and does not have a data dependency on `x`.\n assert_false = control_flow_ops.Assert(False, [42])\n with ops.control_dependencies([assert_false]):\n return array_ops.identity(x)\n\n with ops.device(\"CPU\"):\n pred = array_ops.placeholder(dtypes.bool)\n x = array_ops.placeholder(dtypes.int32)\n cond = control_flow_ops.cond(pred, lambda: x + 1, lambda: AssertFail(x))\n # pylint: disable=unnecessary-lambda\n loop = control_flow_ops.while_loop(lambda y: pred,\n lambda y: AssertFail(y), [x])\n # pylint: enable=unnecessary-lambda\n\n rewriter_config = rewriter_config_pb2.RewriterConfig(\n dependency_optimization=rewriter_config_pb2.RewriterConfig.OFF)\n # Enables inlining.\n config = config_pb2.ConfigProto(\n graph_options=config_pb2.GraphOptions(\n optimizer_options=config_pb2.OptimizerOptions(\n opt_level=config_pb2.OptimizerOptions.L0,\n do_common_subexpression_elimination=True,\n do_function_inlining=True,\n do_constant_folding=True),\n rewrite_options=rewriter_config))\n\n with session.Session(config=config) as sess:\n # Since the 'False' branch is not taken, the assertion should not fire.\n self.assertEqual(4, sess.run(cond, {pred: True, x: 3}))\n\n # The assertion should still fire if the False branch is taken.\n with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,\n \"assertion\"):\n sess.run(cond, {pred: False, x: 3})\n\n # Similarly for loops.\n self.assertEqual(3, sess.run(loop, {pred: False, x: 3}))\n with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,\n \"assertion\"):\n sess.run(loop, {pred: True, x: 3})\n\n def testVar(self):\n\n @function.Defun(dtypes.float32)\n def Foo(x):\n return x * x + 1\n\n g = ops.Graph()\n with g.as_default():\n v = variables.Variable(constant_op.constant(10.0))\n z = Foo(v)\n\n with self.session(graph=g):\n variables.global_variables_initializer().run()\n self.assertAllEqual(z.eval(), 101.)\n\n def testResourceVarAsImplicitInput(self):\n g = ops.Graph()\n with g.as_default(), ops.device(\"cpu:0\"):\n expected_type = dtypes.float32\n expected_shape = tensor_shape.TensorShape((4, 4))\n v = variable_scope.get_variable(\n \"var\", expected_shape, expected_type, use_resource=True)\n\n @function.Defun()\n def Foo():\n captured = array_ops.identity(v)\n self.assertEqual(expected_type, captured.dtype)\n self.assertEqual(expected_shape, captured.shape)\n return captured, array_ops.shape(captured)\n\n expected_val = v.value()\n actual_val, actual_shape = Foo()\n\n with self.session(graph=g):\n v.initializer.run()\n self.assertAllEqual(expected_val.eval(), actual_val.eval())\n self.assertAllEqual(expected_shape, actual_shape.eval())\n\n def testDefineErrors(self):\n with ops.Graph().as_default():\n with self.assertRaisesRegexp(ValueError, \"can not return None\"):\n\n @function.Defun()\n def TwoNone():\n return None, None\n\n _ = TwoNone.definition\n\n with self.assertRaisesRegexp(ValueError, \"are not supported\"):\n\n @function.Defun()\n def DefaultArg(unused_a=12):\n return constant_op.constant([1])\n\n _ = DefaultArg.definition\n with self.assertRaisesRegexp(ValueError, \"are not supported\"):\n\n @function.Defun()\n def KwArgs(**unused_kwargs):\n return constant_op.constant([1])\n\n _ = KwArgs.definition\n with self.assertRaisesRegexp(ValueError, \"specified input types\"):\n\n @function.Defun(dtypes.float32)\n def PlusMinusV2(a, b):\n return a + b, b - a\n\n _ = PlusMinusV2.definition\n with self.assertRaisesRegexp(ValueError, \"specified input types\"):\n\n @function.Defun(dtypes.float32, dtypes.float32, dtypes.float32)\n def PlusMinusV3(a, b):\n return a + b, b - a\n\n _ = PlusMinusV3.definition\n\n def testCallErrors(self):\n\n @function.Defun()\n def Const():\n return constant_op.constant(1)\n\n @function.Defun(dtypes.int32)\n def PlusOne(a):\n return a + 1\n\n @function.Defun(dtypes.int32, dtypes.int32)\n def PlusMinus(a, b):\n return a + b, b - a\n\n with ops.Graph().as_default():\n\n _ = Const()\n # pylint: disable=too-many-function-args\n # pylint: disable=unexpected-keyword-arg\n # pylint: disable=no-value-for-parameter\n with self.assertRaisesRegexp(ValueError, \"arguments: 0\"):\n _ = Const(1)\n with self.assertRaisesRegexp(ValueError, \"arguments: 0\"):\n _ = Const(1, 2)\n\n with self.assertRaisesRegexp(ValueError, \"arguments: 1\"):\n _ = PlusOne()\n _ = PlusOne(1)\n with self.assertRaisesRegexp(ValueError, \"arguments: 1\"):\n _ = PlusOne(1, 2)\n\n with self.assertRaisesRegexp(ValueError, \"arguments: 2\"):\n _ = PlusMinus()\n with self.assertRaisesRegexp(ValueError, \"arguments: 2\"):\n _ = PlusMinus(1)\n _ = PlusMinus(1, 2)\n\n _ = PlusOne(1, name=\"p1\")\n with self.assertRaisesRegexp(ValueError, \"Unknown keyword arguments\"):\n _ = PlusOne(1, device=\"/device:GPU:0\")\n\n def testFunctionDecorator(self):\n\n @function.Defun(dtypes.float32, func_name=\"Minus1\")\n def Minus1(b):\n return b - 1.0\n\n with ops.Graph().as_default():\n call1 = Minus1([2.])\n self.assertTrue(isinstance(Minus1, function._DefinedFunction))\n self.assertEqual(Minus1.name, \"Minus1\")\n # pylint: disable=unexpected-keyword-arg\n call2 = Minus1(call1, name=\"next\")\n # pylint: enable=unexpected-keyword-arg\n self.assertEqual(\"next\", call2.op.name)\n with session.Session() as sess:\n self.assertAllEqual([1], sess.run(call1))\n self.assertAllEqual([0], sess.run(call2))\n\n def testNestedFunction(self):\n\n @function.Defun(dtypes.float32)\n def Cube(x):\n return x * x * x\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def CubeXPlusY(x, y):\n return Cube(x) + y\n\n with ops.Graph().as_default():\n z = CubeXPlusY(3.0, -2.0)\n with self.cached_session():\n self.assertAllEqual(z.eval(), 25.0)\n\n def testNestedDefinedFunction(self):\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def CubeXPlusY(x, y):\n\n @function.Defun(dtypes.float32)\n def Cube(x):\n return x * x * x\n\n return Cube(x) + y\n\n with ops.Graph().as_default():\n z = CubeXPlusY(3.0, -2.0)\n with self.cached_session():\n self.assertAllEqual(z.eval(), 25.0)\n\n def testUnusedFunction(self):\n invoked = False\n # pylint: disable=unused-variable\n @function.Defun()\n def Unused():\n invoked = True\n return constant_op.constant(42.)\n\n self.assertFalse(invoked)\n g = ops.Graph()\n with g.as_default():\n\n @function.Defun()\n def Unused2():\n invoked = True\n return constant_op.constant(7.)\n\n constant_op.constant(3.)\n # pylint: enable=unused-variable\n self.assertFalse(invoked)\n gdef = g.as_graph_def()\n self.assertEqual(0, len(gdef.library.function))\n\n def testReduction(self):\n g = ops.Graph()\n\n # BN0 is computing batch normed matrix along rows.\n def BN0(x):\n mean = math_ops.reduce_mean(x, [0])\n var = math_ops.reduce_mean(math_ops.square(x - mean)) # biased var\n rstd = math_ops.rsqrt(var + 1e-8)\n return (x - mean) * rstd\n\n # Wraps BatchNorm in a tf function.\n @function.Defun(dtypes.float32)\n def BN1(x):\n return BN0(x)\n\n with g.as_default():\n x = array_ops.placeholder(dtypes.float32)\n y0 = BN0(x) # A plain graph\n y1 = BN1(x) # A tf function\n dx0, = gradients_impl.gradients([y0], [x])\n dx1, = gradients_impl.gradients([y1], [x])\n\n # Both should produce the same result and gradient.\n with self.session(graph=g) as sess:\n vals = sess.run([y0, y1, dx0, dx1], {x: np.random.uniform(size=(3, 7))})\n self.assertAllClose(vals[0], vals[1])\n self.assertAllClose(vals[2], vals[3])\n\n def testCapture(self):\n g = ops.Graph()\n with g.as_default():\n w = variables.Variable(constant_op.constant([[1.0]]))\n b = variables.Variable(constant_op.constant([2.0]))\n\n # Foo() captures w and b.\n @function.Defun(dtypes.float32)\n def Foo(x):\n\n # Plus() captures b.\n @function.Defun(dtypes.float32)\n def Plus(y):\n return y + b\n\n return Plus(math_ops.matmul(w, x))\n\n y = Foo(constant_op.constant([[10.]]))\n\n @function.Defun()\n def Bar():\n return w\n\n z = Bar()\n\n with self.session(graph=g):\n variables.global_variables_initializer().run()\n self.assertAllEqual(y.eval(), [[12.0]])\n self.assertAllEqual(z.eval(), [[1.0]])\n\n def testCaptureControls(self):\n g = ops.Graph()\n with g.as_default():\n x = constant_op.constant([10.0])\n x = logging_ops.Print(x, [x], \"outer\")\n\n @function.Defun(dtypes.float32)\n def Foo(y):\n with ops.control_dependencies([x]):\n y = logging_ops.Print(y, [y], \"inner\")\n return y\n\n with self.assertRaisesRegexp(ValueError, \"not an element of this graph.\"):\n # NOTE: We still do not support capturing control deps.\n _ = Foo(x)\n\n def testCaptureInWhileLoop(self):\n g = ops.Graph()\n with g.as_default():\n x = constant_op.constant(1)\n\n @function.Defun()\n def Foo():\n return control_flow_ops.while_loop(lambda i: i < 10, lambda i: i + x,\n [0])\n\n y = Foo()\n\n with self.session(graph=g) as sess:\n self.assertEqual(sess.run(y), 10)\n\n def testCaptureInCond(self):\n g = ops.Graph()\n with g.as_default():\n x = constant_op.constant(1)\n\n @function.Defun(dtypes.bool)\n def Foo(pred):\n return control_flow_ops.cond(pred, lambda: x, lambda: x + 1)\n\n y = Foo(True)\n z = Foo(False)\n\n with self.session(graph=g) as sess:\n self.assertEqual(sess.run(y), 1)\n self.assertEqual(sess.run(z), 2)\n\n def testStableName(self):\n\n @function.Defun()\n def Foo(x, y, z):\n return math_ops.tanh(math_ops.matmul(x, y) + z)\n\n if sys.byteorder == \"big\":\n self.assertEqual(\"Foo_kEdkAG8SJvg\",\n Foo.instantiate([dtypes.float32] * 3).name)\n else:\n self.assertEqual(\"Foo_aCYSbwBkR5A\",\n Foo.instantiate([dtypes.float32] * 3).name)\n\n def testSignatureHash(self):\n # Foo.Inner and Bar.Inner have identical function body but have\n # different signatures. They should be treated as two different functions.\n\n @function.Defun()\n def Foo(x):\n\n @function.Defun()\n def Inner(x):\n return x + 10.\n\n return Inner(x)\n\n @function.Defun()\n def Bar(x):\n\n @function.Defun()\n def Inner(x, unused_y, unused_z):\n return x + 10.\n\n return Inner(x, 2., 3.)\n\n g = ops.Graph()\n with g.as_default():\n x = constant_op.constant(10.0)\n y = Foo(x)\n z = Bar(x)\n\n with self.session(graph=g) as sess:\n v0, v1 = sess.run([y, z])\n self.assertAllEqual(v0, 20.)\n self.assertAllEqual(v1, 20.)\n\n def testShapeFunction(self):\n\n @function.Defun(\n dtypes.float32, shape_func=lambda op: [op.inputs[0].get_shape()])\n def Foo(x):\n return x + 1.0\n\n @function.Defun(\n shape_func=lambda op: [[1] + op.inputs[0].get_shape().as_list()])\n def Bar(x):\n return array_ops.stack([x])\n\n g = ops.Graph()\n with g.as_default():\n x = Foo([1.0, 2.0])\n self.assertEqual(x.get_shape().as_list(), [2])\n y = Bar(array_ops.zeros([1, 2, 3]))\n self.assertAllEqual(y.get_shape().as_list(), [1, 1, 2, 3])\n\n def testVariableReuse(self):\n\n def LinearWithReuse(input_tensor, reuse=None):\n size = input_tensor.shape.dims[1]\n with variable_scope.variable_scope(\"linear\", reuse=reuse):\n w = variable_scope.get_variable(\n \"w\", shape=[size, size], dtype=input_tensor.dtype)\n return math_ops.matmul(input_tensor, w)\n\n @function.Defun(dtypes.float32)\n def Foo(inputs):\n inputs = array_ops.reshape(inputs, [32, 100])\n hidden = LinearWithReuse(inputs)\n return LinearWithReuse(hidden, reuse=True)\n\n input_op = array_ops.placeholder(shape=[32, 100], dtype=dtypes.float32)\n output_op = Foo(input_op)\n\n global_vars = variables.global_variables()\n self.assertEqual(len(global_vars), 1)\n self.assertEqual(global_vars[0].name, \"linear/w:0\")\n\n with session.Session() as sess:\n sess.run(variables.global_variables_initializer())\n output_val = sess.run(\n output_op, feed_dict={input_op: np.random.rand(32, 100)})\n self.assertEqual(output_val.shape, (32, 100))\n\n def testFunctionCallInDifferentVariableScopes(self):\n\n @function.Defun(dtypes.float32)\n def Foo(inputs):\n var = variable_scope.get_variable(\n \"var\",\n shape=[10],\n dtype=dtypes.float32,\n initializer=init_ops.ones_initializer())\n return inputs + var\n\n input_op = array_ops.placeholder(shape=[10], dtype=dtypes.float32)\n with variable_scope.variable_scope(\"vs1\"):\n out1_op = Foo(input_op)\n\n with variable_scope.variable_scope(\"vs2\"):\n out2_op = Foo(input_op)\n\n global_vars = variables.global_variables()\n self.assertEqual(len(global_vars), 1)\n self.assertEqual(global_vars[0].name, \"vs1/var:0\")\n\n with session.Session() as sess:\n sess.run(variables.global_variables_initializer())\n out1, out2 = sess.run(\n [out1_op, out2_op], feed_dict={input_op: np.linspace(1, 10, 10)})\n self.assertAllEqual(out1, np.linspace(2, 11, 10))\n self.assertAllEqual(out2, np.linspace(2, 11, 10))\n\n def testTwoInputsSameOp(self):\n g = ops.Graph()\n with g.as_default():\n m = array_ops.placeholder(dtypes.float32)\n s, u, v = linalg_ops.svd(m)\n ss = math_ops.reduce_sum(s)\n uu = math_ops.reduce_sum(u)\n vv = math_ops.reduce_sum(v)\n result = ss + uu + vv\n f = graph_to_function_def.graph_to_function_def(\n g,\n g.get_operations()[1:], # skip the placeholder\n [s, u, v],\n [result])\n self.assertEqual(len(f.signature.input_arg), 3)\n\n def testGradientWithIntegerFunctionArgument(self):\n\n @function.Defun(dtypes.int32, dtypes.float32)\n def Foo(t, x):\n return x[t]\n\n g = ops.Graph()\n with g.as_default():\n inp = array_ops.placeholder(dtypes.float32)\n t = constant_op.constant(0, dtypes.int32)\n out = Foo(t, inp)\n dinp, = gradients_impl.gradients(out, [inp])\n\n x = np.zeros((2,)).astype(np.float32)\n with session.Session(graph=g) as sess:\n self.assertAllClose(\n np.array([1.0, 0.0]).astype(np.float32), sess.run(dinp, {inp: x}))\n\n def testFunctionMarkedStateful(self):\n\n @function.Defun(dtypes.int32, dtypes.float32)\n def Foo(t, x):\n return x[t]\n\n @function.Defun(dtypes.int64)\n def Bar(x):\n return x\n\n # NOTE(mrry): All functions are currently considered stateless by the\n # runtime, so we simulate a \"stateful\" function.\n # TODO(b/70565970): Remove this hack when we are able to build stateful\n # functions using the API.\n # pylint: disable=protected-access\n Foo._signature.is_stateful = True\n Bar._signature.is_stateful = True\n # pylint: enable=protected-access\n\n result_1 = Foo(3, [1.0, 2.0, 3.0, 4.0])\n result_2 = Bar(constant_op.constant(100, dtype=dtypes.int64))\n\n with session.Session() as sess:\n self.assertEqual(4.0, sess.run(result_1))\n self.assertEqual(100, sess.run(result_2))\n self.assertEqual((4.0, 100), sess.run((result_1, result_2)))\n\n def testStatefulFunction(self):\n\n @function.Defun()\n def FunctionWithStatelessOp():\n return constant_op.constant(42.0)\n\n @function.Defun()\n def FunctionWithStatefulOp():\n return random_ops.random_uniform([100], maxval=10, dtype=dtypes.int32)\n\n @function.Defun()\n def FunctionWithStatelessFunctionCall():\n return FunctionWithStatelessOp()\n\n @function.Defun()\n def FunctionWithStatefulFunctionCall():\n return FunctionWithStatefulOp()\n\n # Test that the `is_stateful` bit is propagated.\n self.assertFalse(FunctionWithStatelessOp.definition.signature.is_stateful)\n self.assertTrue(FunctionWithStatefulOp.definition.signature.is_stateful)\n self.assertFalse(\n FunctionWithStatelessFunctionCall.definition.signature.is_stateful)\n self.assertTrue(\n FunctionWithStatefulFunctionCall.definition.signature.is_stateful)\n\n # Ensure that two invocations of the same random-number-generating\n # function produce different results.\n result1 = FunctionWithStatefulFunctionCall()\n result2 = FunctionWithStatefulFunctionCall()\n\n # Statefulness affects how the function is treated by the various\n # optimization passes, so run the test in each optimizer\n # configuration.\n for config in _OptimizerOptions():\n with session.Session(config=config) as sess:\n val1, val2 = sess.run((result1, result2))\n self.assertFalse(all(val1 == val2))\n val3, val4 = sess.run((result1, result2))\n self.assertFalse(all(val3 == val1))\n self.assertFalse(all(val4 == val2))\n\n def testSameFunctionOnTwoDevices(self):\n\n @function.Defun(dtypes.float32)\n def AddOne(x):\n return x + 1.0\n\n with ops.device(\"/cpu:0\"):\n f_0 = AddOne(41.0)\n\n with ops.device(\"/cpu:1\"):\n f_1 = AddOne(43.0)\n\n for config in _OptimizerOptions():\n config.device_count[\"CPU\"] = 2\n with session.Session(config=config) as sess:\n self.assertEqual(42.0, sess.run(f_0))\n self.assertEqual(44.0, sess.run(f_1))\n self.assertEqual((42.0, 44.0), sess.run((f_0, f_1)))\n\n def testGuaranteedConstsAreCaptured(self):\n var = variables.Variable(1.0)\n const = array_ops.guarantee_const(var)\n also_const = array_ops.identity(const)\n still_const = array_ops.identity(also_const)\n not_const = still_const + var\n also_not_const = array_ops.placeholder(dtypes.float32)\n\n @function.Defun()\n def CapturesGuaranteedConst():\n output = const + also_const + still_const + not_const + also_not_const\n first, second, third, fourth, fifth = function.get_extra_args()\n self.assertEqual(\"GuaranteeConst\", first.consumers()[0].node_def.op)\n self.assertEqual(\"GuaranteeConst\", second.consumers()[0].node_def.op)\n self.assertEqual(\"GuaranteeConst\", third.consumers()[0].node_def.op)\n self.assertNotEqual(\"GuaranteeConst\", fourth.consumers()[0].node_def.op)\n self.assertNotEqual(\"GuaranteeConst\", fifth.consumers()[0].node_def.op)\n return output\n\n with self.test_session(use_gpu=False) as sess:\n sess.run(var.initializer)\n _ = sess.run(CapturesGuaranteedConst(), {also_not_const: 1.0})\n\n def testSameFunctionDifferentGrads(self):\n\n def PartOne(x):\n\n # Default grad is dx = dy * 2\n @function.Defun(dtypes.float32)\n def Foo(x):\n return x * 2\n\n return Foo(x)\n\n def PartTwo(x):\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def Bar(x, dy):\n return x + dy # crazy backprop\n\n @function.Defun(dtypes.float32, grad_func=Bar)\n def Foo(x):\n return x * 2\n\n return Foo(x)\n\n def PartThree(x):\n\n def Bar(op, dy):\n return op.inputs[0] * dy / 2 # crazy backprop\n\n @function.Defun(dtypes.float32, python_grad_func=Bar)\n def Foo(x):\n return x * 2\n\n return Foo(x)\n\n g = ops.Graph()\n with g.as_default():\n x = constant_op.constant(100.)\n x0 = x\n y0 = PartOne(x0)\n dx0, = gradients_impl.gradients(ys=[y0], xs=[x0])\n x1 = x\n y1 = PartTwo(x1)\n dx1, = gradients_impl.gradients(ys=[y1], xs=[x1])\n x2 = x\n y2 = PartThree(x2)\n dx2, = gradients_impl.gradients(ys=[y2], xs=[x2])\n\n with self.session(graph=g) as sess:\n v0, v1, v2 = sess.run([dx0, dx1, dx2])\n\n self.assertAllEqual(v0, 2.)\n self.assertAllEqual(v1, 101.)\n self.assertAllEqual(v2, 50.)\n\n\n@test_util.with_c_shapes\nclass FunctionsFromProtos(test.TestCase):\n\n def expectFunctionsEqual(self, func, grad_func=None, new_func=None):\n if new_func is None:\n # Make a copy of func.definition to avoid any bugs masked by using the\n # same object\n serialized_fdef = func.definition.SerializeToString()\n # Serialize and then deserialize `func` to create `new_func`\n fdef = function_pb2.FunctionDef.FromString(serialized_fdef)\n new_func = function._from_definition(fdef, grad_func=grad_func)\n self.assertEqual(func.name, new_func.name)\n self.assertEqual(func.definition, new_func.definition)\n self.assertEqual(func.grad_func_name, new_func.grad_func_name)\n self.assertEqual(func.declared_input_types, new_func.declared_input_types)\n self.assertEqual(func.captured_inputs, new_func.captured_inputs)\n\n def testBasic(self):\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def Foo(x, y):\n return x + y\n\n self.expectFunctionsEqual(Foo)\n\n def testGradFunc(self):\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def G(x, dy):\n return x * dy\n\n @function.Defun(dtypes.float32, grad_func=G)\n def F(x):\n return math_ops.exp(x) - math_ops.exp(-x)\n\n self.expectFunctionsEqual(F, grad_func=G)\n\n def testCapturedInputs(self):\n c = constant_op.constant(10, dtypes.int64)\n\n @function.Defun(dtypes.int64)\n def Foo(x):\n return x + c\n\n new_func = function._from_definition(Foo.definition)\n\n self.assertEqual(Foo.name, new_func.name)\n self.assertEqual(Foo.definition, new_func.definition)\n self.assertEqual(Foo.grad_func_name, new_func.grad_func_name)\n\n # Captured inputs are added as regular inputs to the function definition\n self.assertEqual(new_func.declared_input_types,\n Foo.declared_input_types + (dtypes.int64,))\n self.assertEqual(len(new_func.captured_inputs), 0)\n\n def testNestedFunctions(self):\n\n @function.Defun(dtypes.float32)\n def Outer(x):\n\n @function.Defun(dtypes.float32)\n def Inner(y):\n return y + 1\n\n return Inner(Inner(x))\n\n self.expectFunctionsEqual(Outer)\n\n def testFromLibrary(self):\n # Define some functions with different gradient functions. Note that many of\n # the below functions are identical since function bodies don't matter for\n # this test.\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def G1(x, dy):\n return x * dy\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def G2(x, dy):\n return x * dy\n\n # F1 and F2 have the same gradient function\n @function.Defun(dtypes.float32, grad_func=G1)\n def F1(x):\n return math_ops.exp(x) - math_ops.exp(-x)\n\n @function.Defun(dtypes.float32, grad_func=G1)\n def F2(x):\n return math_ops.exp(x) - math_ops.exp(-x)\n\n # F3 has a different gradient function\n @function.Defun(dtypes.float32, grad_func=G2)\n def F3(x):\n return math_ops.exp(x) - math_ops.exp(-x)\n\n # F4 has no gradient function\n @function.Defun(dtypes.float32)\n def F4(x):\n return math_ops.exp(x) - math_ops.exp(-x)\n\n # Instantiate all functions\n g = ops.Graph()\n with g.as_default():\n c = constant_op.constant(1.0, dtypes.float32)\n f1 = F1(c)\n f2 = F2(c)\n f3 = F3(c)\n f4 = F4(c)\n gradients_impl.gradients([f1, f2, f3, f4], c)\n\n library = g.as_graph_def().library\n new_funcs = function._from_library(library)\n\n def CheckNewFunc(func):\n new_func = [f for f in new_funcs if f.name == func.name]\n self.assertEqual(len(new_func), 1)\n self.expectFunctionsEqual(func, new_func=new_func[0])\n\n CheckNewFunc(G1)\n CheckNewFunc(G2)\n CheckNewFunc(F1)\n CheckNewFunc(F2)\n CheckNewFunc(F3)\n CheckNewFunc(F4)\n\n def testFromLibraryEmptyLib(self):\n library = function_pb2.FunctionDefLibrary()\n self.assertEqual(len(function._from_library(library)), 0)\n\n def testFromLibraryMissingFuncDef(self):\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def G1(x, dy):\n return x * dy\n\n @function.Defun(dtypes.float32)\n def F1(x):\n return math_ops.exp(x) - math_ops.exp(-x)\n\n gradient = function_pb2.GradientDef()\n gradient.function_name = F1.name\n gradient.gradient_func = G1.name\n\n # Create invalid function def that is missing G1 function def\n library = function_pb2.FunctionDefLibrary()\n library.gradient.extend([gradient])\n library.function.extend([F1.definition])\n\n with self.assertRaisesRegexp(\n ValueError,\n \"FunctionDefLibrary missing 'G1_[0-9a-zA-Z]{8,11}' FunctionDef\"):\n function._from_library(library)\n\n # Create invalid function def that is missing F1 function def\n library = function_pb2.FunctionDefLibrary()\n library.gradient.extend([gradient])\n library.function.extend([G1.definition])\n\n with self.assertRaisesRegexp(\n ValueError,\n \"FunctionDefLibrary missing 'F1_[0-9a-zA-Z]{8,11}' FunctionDef\"):\n function._from_library(library)\n\n def testFromLibraryCyclicGradFuncs(self):\n\n @function.Defun(dtypes.float32)\n def F1(x):\n return math_ops.exp(x) - math_ops.exp(-x)\n\n @function.Defun(dtypes.float32)\n def F2(x):\n return math_ops.exp(x) - math_ops.exp(-x)\n\n # Create invalid function def library where F1 has gradient function F2 and\n # F2 has gradient function F1\n library = function_pb2.FunctionDefLibrary()\n library.function.extend([F1.definition, F2.definition])\n\n gradient1 = function_pb2.GradientDef()\n gradient1.function_name = F1.name\n gradient1.gradient_func = F2.name\n\n gradient2 = function_pb2.GradientDef()\n gradient2.function_name = F2.name\n gradient2.gradient_func = F1.name\n\n library.gradient.extend([gradient1, gradient2])\n\n with self.assertRaisesRegexp(\n ValueError, \"FunctionDefLibrary contains cyclic gradient functions!\"):\n function._from_library(library)\n\n def testExperimentalAttrs(self):\n\n @function.Defun(dtypes.int32, experimental_tag=\"tag_value\")\n def FunctionWithStrAttr(i):\n return array_ops.identity(i)\n\n @function.Defun(dtypes.int32, experimental_tag=123)\n def FunctionWithIntAttr(i):\n return array_ops.identity(i)\n\n @function.Defun(dtypes.int32, experimental_tag=123.0)\n def FunctionWithFloatAttr(i):\n return array_ops.identity(i)\n\n @function.Defun(dtypes.int32, experimental_tag=True)\n def FunctionWithBoolAttr(i):\n return array_ops.identity(i)\n\n self.assertTrue(\"experimental_tag\" in FunctionWithStrAttr.definition.attr)\n self.assertEqual(FunctionWithStrAttr.definition.attr[\"experimental_tag\"].s,\n b\"tag_value\")\n self.assertTrue(\"experimental_tag\" in FunctionWithIntAttr.definition.attr)\n self.assertEqual(FunctionWithIntAttr.definition.attr[\"experimental_tag\"].i,\n 123)\n self.assertTrue(\"experimental_tag\" in FunctionWithFloatAttr.definition.attr)\n self.assertEqual(\n FunctionWithFloatAttr.definition.attr[\"experimental_tag\"].f, 123.0)\n self.assertTrue(\"experimental_tag\" in FunctionWithBoolAttr.definition.attr)\n self.assertEqual(FunctionWithBoolAttr.definition.attr[\"experimental_tag\"].b,\n True)\n\n\n@test_util.with_c_shapes\nclass FunctionOverloadTest(test.TestCase):\n\n def testBasic(self):\n\n @function.Defun()\n def Sinh(x):\n return 1 / 2. * (math_ops.exp(x) - math_ops.exp(-x))\n\n g = ops.Graph()\n with g.as_default():\n x = Sinh(constant_op.constant(0.25, dtypes.float32))\n y = Sinh(constant_op.constant(0.25, dtypes.float64))\n\n with self.session(graph=g):\n self.assertAllClose(x.eval(), np.sinh(0.25))\n self.assertAllClose(y.eval(), np.sinh(0.25))\n\n def testGradient(self):\n\n @function.Defun(func_name=\"Spec\")\n def G(x, dy):\n return x * dy\n\n @function.Defun(grad_func=G)\n def F(x):\n return math_ops.exp(x) - math_ops.exp(-x)\n\n for dtype in [dtypes.float32, dtypes.float64]:\n g = ops.Graph()\n with g.as_default():\n x = constant_op.constant(0.25, dtype)\n y = F(x)\n dx, = gradients_impl.gradients(y, x)\n\n with self.session(graph=g):\n self.assertAllClose(dx.eval(), 0.25)\n\n def testDocString(self):\n\n @function.Defun()\n def Foo(x):\n \"\"\"Successor of x.\"\"\"\n return x + 1\n\n g = ops.Graph()\n with g.as_default():\n _ = Foo(1)\n\n self.assertEqual(g.as_graph_def().library.function[0].signature.description,\n \"Successor of x.\")\n\n\n@test_util.with_c_shapes\nclass FunctionCaptureByValueTest(test.TestCase):\n\n def testCaptureByValue(self):\n g = ops.Graph()\n with g.as_default():\n w = constant_op.constant([[1.0]])\n b = constant_op.constant([2.0])\n\n # Foo() captures w and b.\n @function.Defun(dtypes.float32, capture_by_value=True)\n def Foo(x):\n\n # Plus() captures b.\n @function.Defun(dtypes.float32, capture_by_value=True)\n def Plus(y):\n return y + b\n\n self.assertEqual(0, len(Plus.captured_inputs))\n\n return Plus(math_ops.matmul(w, x))\n\n y = Foo(constant_op.constant([[10.]]))\n\n self.assertEqual(0, len(Foo.captured_inputs))\n\n with self.session(graph=g):\n self.assertAllEqual(y.eval(), [[12.0]])\n\n\n@test_util.with_c_shapes\nclass UnrollLSTMTest(test.TestCase):\n BATCH_SIZE = 16\n LSTM_DIMS = 32\n NUM_UNROLL = 20\n\n def _Weights(self):\n dims = self.LSTM_DIMS\n return random_ops.random_uniform([2 * dims, 4 * dims], -1, 1, seed=123456)\n\n def _Input(self):\n return random_ops.random_uniform(\n [self.NUM_UNROLL, self.BATCH_SIZE, self.LSTM_DIMS], seed=654321)\n\n # Helper to construct a LSTM cell graph.\n @classmethod\n def LSTMCell(cls, x, mprev, cprev, weights):\n xm = array_ops.concat([x, mprev], 1)\n i_i, i_g, f_g, o_g = array_ops.split(\n value=math_ops.matmul(xm, weights), num_or_size_splits=4, axis=1)\n new_c = math_ops.sigmoid(f_g) * cprev + math_ops.sigmoid(\n i_g) * math_ops.tanh(i_i)\n new_c = math_ops.maximum(math_ops.minimum(new_c, 50.0), -50.0)\n new_m = math_ops.sigmoid(o_g) * math_ops.tanh(new_c)\n return new_m, new_c\n\n def _BuildForward(self, weights, inp, mode=\"cell\"):\n\n def Loop(cell, w, i):\n x = array_ops.unstack(i, self.NUM_UNROLL)\n m = array_ops.zeros_like(x[0])\n c = array_ops.zeros_like(x[0])\n for i in range(self.NUM_UNROLL):\n m, c = cell(x[i], m, c, w)\n return m\n\n cell = UnrollLSTMTest.LSTMCell\n if mode == \"complete\":\n # Constructs the complete graph in python.\n return Loop(cell, weights, inp)\n\n cell = function.Defun(dtypes.float32, dtypes.float32, dtypes.float32,\n dtypes.float32)(\n cell)\n if mode == \"cell\":\n # Just represent the LSTM as a function.\n return Loop(cell, weights, inp)\n\n if mode == \"loop\":\n # Wraps the whole loop as a function.\n @function.Defun(dtypes.float32, dtypes.float32)\n def LSTMLoop(w, i):\n return Loop(cell, w, i)\n\n return LSTMLoop(weights, inp)\n\n if mode == \"loop10\":\n # Wraps 10 lstm steps into one function, and the whole loop\n # into another calling the formers.\n\n # Groups 10 steps at a time.\n @function.Defun(dtypes.float32, dtypes.float32, dtypes.float32,\n *([dtypes.float32] * 10))\n def Loop10(w, m, c, *args):\n for x in args:\n m, c = cell(x, m, c, w)\n return m, c\n\n @function.Defun(dtypes.float32, dtypes.float32)\n def LSTMLoop10(weights, inp):\n x = array_ops.unstack(inp, self.NUM_UNROLL)\n m = array_ops.zeros_like(x[0])\n c = array_ops.zeros_like(x[0])\n assert self.NUM_UNROLL % 10 == 0\n for i in range(0, self.NUM_UNROLL, 10):\n m, c = Loop10(weights, m, c, *x[i:i + 10])\n return m\n\n return LSTMLoop10(weights, inp)\n\n def testUnrollLSTM(self):\n # Run one step of the unrolled lstm graph.\n def RunForward(mode, cfg=None):\n tf_logging.info(\"mode = %s\", mode)\n g = ops.Graph()\n start = time.time()\n with g.as_default():\n weights = self._Weights()\n inp = self._Input()\n m = self._BuildForward(weights, inp, mode)\n gdef = g.as_graph_def()\n finish = time.time()\n tf_logging.info(\"time: %f txt size: %d gdef bin size: %d\", finish - start,\n len(str(gdef)), len(gdef.SerializeToString()))\n with g.as_default(), session.Session(config=cfg) as sess:\n return sess.run(m)\n\n mv0 = RunForward(\"complete\")\n for cfg in _OptimizerOptions():\n tf_logging.info(\"cfg = %s\", cfg)\n mv1 = RunForward(\"cell\", cfg)\n mv2 = RunForward(\"loop\", cfg)\n mv3 = RunForward(\"loop10\", cfg)\n self.assertAllClose(mv0, mv1, rtol=1e-4)\n self.assertAllClose(mv0, mv2, rtol=1e-4)\n self.assertAllClose(mv0, mv3, rtol=1e-4)\n\n def testUnrollLSTMGrad(self):\n # Run one step of the unrolled lstm graph.\n def RunForwardBackward(mode, cfg=None):\n tf_logging.info(\"mode = %s\", mode)\n g = ops.Graph()\n start = time.time()\n with g.as_default():\n weights = self._Weights()\n inp = self._Input()\n m = self._BuildForward(weights, inp, mode)\n loss = math_ops.reduce_sum(math_ops.square(m))\n dw = gradients_impl.gradients([loss], [weights])\n gdef = g.as_graph_def()\n finish = time.time()\n tf_logging.info(\"time: %f txt size: %d gdef bin size: %d\", finish - start,\n len(str(gdef)), len(gdef.SerializeToString()))\n with g.as_default(), session.Session(config=cfg) as sess:\n return sess.run(dw)\n\n d0 = RunForwardBackward(\"complete\")\n for cfg in _OptimizerOptions():\n tf_logging.info(\"cfg = %s\", cfg)\n d1 = RunForwardBackward(\"cell\", cfg)\n d2 = RunForwardBackward(\"loop\", cfg)\n d3 = RunForwardBackward(\"loop10\", cfg)\n self.assertAllClose(d0, d1, rtol=1e-4, atol=1e-4)\n self.assertAllClose(d0, d2, rtol=1e-4, atol=1e-4)\n self.assertAllClose(d0, d3, rtol=1e-4, atol=1e-4)\n\n\n@test_util.with_c_shapes\nclass FunctionInlineControlTest(test.TestCase):\n\n def testFoo(self):\n dtype = dtypes.float32\n cfg = config_pb2.ConfigProto(\n graph_options=config_pb2.GraphOptions(\n optimizer_options=config_pb2.OptimizerOptions(\n opt_level=config_pb2.OptimizerOptions.L0,\n do_common_subexpression_elimination=True,\n do_function_inlining=True,\n do_constant_folding=True)))\n cell_func_call_pattern = re.compile(r\"Cell[^/]*\\(\")\n for noinline in [False, True]:\n\n @function.Defun(dtype, noinline=noinline)\n def Cell(v):\n # If v is a vector [n, 1], x is a big square matrix.\n x = math_ops.tanh(v + array_ops.transpose(v, [1, 0]))\n return math_ops.reduce_sum(x, 1, keepdims=True)\n\n @function.Defun(dtype)\n def Forward(x):\n for _ in range(10):\n # pylint: disable=cell-var-from-loop\n x = Cell(x)\n return math_ops.reduce_sum(x, [0, 1])\n\n self.assertEqual(noinline, Cell.definition.attr[\"_noinline\"].b)\n\n g = ops.Graph()\n with g.as_default():\n x = array_ops.placeholder(dtype)\n y = Forward(x)\n dx, = gradients_impl.gradients([y], [x])\n\n np.random.seed(321)\n inp = np.random.uniform(-1, 1, [16, 1]).astype(np.float32)\n run_metadata = config_pb2.RunMetadata()\n with session.Session(graph=g, config=cfg) as sess:\n ans = sess.run(\n [y, dx], {x: inp},\n run_metadata=run_metadata,\n options=config_pb2.RunOptions(\n trace_level=config_pb2.RunOptions.FULL_TRACE))\n print(ans[0], np.sum(ans[1]))\n self.assertAllClose(ans[0], 255.971, rtol=1e-3)\n self.assertAllClose(np.sum(ans[1]), 13.0408, rtol=1e-3)\n\n def MetadataHasCell(run_metadata):\n for dev_stats in run_metadata.step_stats.dev_stats:\n for node_stats in dev_stats.node_stats:\n if cell_func_call_pattern.search(node_stats.timeline_label):\n return True\n return False\n\n self.assertEqual(MetadataHasCell(run_metadata), noinline)\n\n\[email protected](*[dtypes.float32] * 3)\ndef Linear(w, b, x):\n return nn_ops.relu(math_ops.matmul(x, w) + b)\n\n\[email protected](*[dtypes.float32] * 5)\ndef Linear2(w1, b1, w2, b2, x):\n return Linear(w2, b2, Linear(w1, b1, x))\n\n\[email protected](*[dtypes.float32] * 3)\ndef LinearWithCApi(w, b, x):\n return nn_ops.relu(math_ops.matmul(x, w) + b)\n\n\[email protected](*[dtypes.float32] * 5)\ndef Linear2WithCApi(w1, b1, w2, b2, x):\n return LinearWithCApi(w2, b2, LinearWithCApi(w1, b1, x))\n\n\nclass ModuleFunctionTest(test.TestCase):\n\n def testBasic(self):\n with ops.Graph().as_default():\n a, b, c, d, e = [\n constant_op.constant([[_]], dtype=dtypes.float32) for _ in range(5)\n ]\n y = LinearWithCApi(a, b, c)\n z = Linear2WithCApi(a, b, c, d, e)\n with session.Session() as sess:\n self.assertAllEqual([[1]], sess.run(y))\n self.assertAllEqual([[5]], sess.run(z))\n\n\n@test_util.with_c_shapes\nclass VariableHoistingTest(test.TestCase):\n\n def _testSimpleModel(self, use_forward_func, use_resource=False):\n\n def _Model(x):\n w = variable_scope.get_variable(\n \"w\", (64, 64),\n initializer=init_ops.random_uniform_initializer(seed=312),\n use_resource=use_resource)\n b = variable_scope.get_variable(\n \"b\", (64),\n initializer=init_ops.zeros_initializer(),\n use_resource=use_resource),\n return math_ops.sigmoid(math_ops.matmul(x, w) + b)\n\n @function.Defun()\n def Model(x):\n return _Model(x)\n\n cvars = []\n\n @function.Defun()\n def Grad(x, y0):\n if use_forward_func:\n y = Model(x)\n else:\n y = _Model(x)\n loss = math_ops.reduce_mean(\n math_ops.reduce_sum(y0 * math_ops.log(y), 1), 0)\n arg_w, arg_b = function.get_extra_args()\n self.assertEqual(arg_w.get_shape(), tensor_shape.TensorShape([64, 64]))\n self.assertEqual(arg_b.get_shape(), tensor_shape.TensorShape([64]))\n dw, db = gradients_impl.gradients(loss, [arg_w, arg_b])\n cvars.extend(function.get_extra_vars())\n return loss, dw, db\n\n g = ops.Graph()\n with g.as_default():\n x = random_ops.random_normal([64, 64], seed=100)\n y0 = random_ops.random_normal([64, 64], seed=200)\n with variable_scope.variable_scope(\"Foo\"):\n loss, dw, db = Grad(x, y0)\n\n self.assertEqual(2, len(cvars))\n w, b = cvars[:2]\n self.assertEqual(\"Foo/w\", w.op.name)\n self.assertEqual(\"Foo/b\", b.op.name)\n\n with self.session(graph=g) as sess:\n sess.run(variables.global_variables_initializer())\n w, b, x, y0, loss, dw, db = sess.run([w, b, x, y0, loss, dw, db])\n\n self.assertAllEqual(w.shape, (64, 64))\n self.assertAllClose(np.sum(w), 2050.44)\n self.assertAllEqual(b.shape, (64,))\n self.assertAllClose(np.sum(b), 0.0)\n self.assertAllClose(loss, -2.27, rtol=1e-2)\n self.assertAllEqual(dw.shape, (64, 64))\n self.assertAllClose(np.sum(dw), -1.04, rtol=1e-2)\n self.assertAllEqual(db.shape, (64,))\n self.assertAllClose(np.sum(db), 0.509, rtol=1e-2)\n\n def testBasic(self):\n self._testSimpleModel(True)\n self._testSimpleModel(False)\n\n def testBasicResource(self):\n self._testSimpleModel(True, use_resource=True)\n self._testSimpleModel(False, use_resource=True)\n\n\nclass DevicePlacementTest(test.TestCase):\n\n def testNoDeviceGraph(self):\n with ops.Graph().as_default():\n\n @function.Defun(*[dtypes.float32] * 2)\n def Matmul(a, b):\n return math_ops.matmul(a, b)\n\n Matmul(1., 2.)\n\n gdef = ops.get_default_graph().as_graph_def()\n self.assertAllEqual(len(gdef.library.function), 1)\n fdef = gdef.library.function[0]\n\n for node in fdef.node_def:\n self.assertAllEqual(node.device, \"\")\n\n def testNestedDevices(self):\n with ops.Graph().as_default(), ops.device(\"CPU:0\"):\n\n @function.Defun(*[dtypes.float32] * 2)\n def Matmul(a, b):\n return math_ops.matmul(a, b)\n\n with ops.device(\"CPU:1\"):\n\n @function.Defun(*[dtypes.float32] * 2)\n def Divide(a, b):\n return math_ops.divide(a, b)\n\n Divide(Matmul(1., 2.), 3.)\n\n gdef = ops.get_default_graph().as_graph_def()\n matmul_fdef = [\n f for f in gdef.library.function if \"Matmul\" in f.signature.name\n ]\n divide_fdef = [\n f for f in gdef.library.function if \"Divide\" in f.signature.name\n ]\n self.assertAllEqual(len(matmul_fdef), 1)\n self.assertAllEqual(len(divide_fdef), 1)\n for node in matmul_fdef[0].node_def:\n self.assertAllEqual(node.device, \"/device:CPU:0\")\n for node in divide_fdef[0].node_def:\n self.assertAllEqual(node.device, \"/device:CPU:1\")\n\n def _testNestedDeviceWithSameFunction(self, func_name):\n\n def MatmulWrap(a, b):\n\n @function.Defun(\n func_name=func_name, *[dtypes.int32] * 2)\n def Matmul(a, b):\n return math_ops.matmul(a, b)\n\n return Matmul(a, b)\n\n with ops.Graph().as_default(), ops.device(\"CPU:0\"):\n c = MatmulWrap(1, 2)\n\n with ops.device(\"CPU:1\"):\n MatmulWrap(c, 3)\n\n gdef = ops.get_default_graph().as_graph_def()\n\n devices = []\n for node in gdef.library.function[0].node_def:\n devices.append(node.device)\n for node in gdef.library.function[1].node_def:\n devices.append(node.device)\n\n self.assertAllEqual(sorted(devices), [\"/device:CPU:0\", \"/device:CPU:1\"])\n\n def testFunctionWithName(self):\n with self.assertRaises(InvalidArgumentError) as cm:\n self._testNestedDeviceWithSameFunction(\"MatmulTest\")\n self.assertEqual(\n cm.exception.message,\n \"Cannot add function \\'MatmulTest\\' because a different \"\n \"function with the same name already exists.\")\n\n def testFunctionWithoutName(self):\n self._testNestedDeviceWithSameFunction(None)\n\n\nif __name__ == \"__main__\":\n test.main()\n"
] | [
[
"numpy.sum",
"tensorflow.python.framework.function._from_definition",
"tensorflow.core.framework.function_pb2.GradientDef",
"tensorflow.python.ops.math_ops.tanh",
"numpy.random.seed",
"tensorflow.python.ops.variable_scope.variable_scope",
"tensorflow.python.ops.gradients_impl.gradients",
"tensorflow.python.ops.math_ops.rsqrt",
"tensorflow.python.framework.tensor_shape.TensorShape",
"tensorflow.core.protobuf.config_pb2.RunOptions",
"numpy.tanh",
"tensorflow.python.framework.constant_op.constant",
"tensorflow.python.ops.array_ops.reshape",
"tensorflow.core.protobuf.config_pb2.OptimizerOptions",
"tensorflow.python.ops.init_ops.random_uniform_initializer",
"tensorflow.python.framework.ops.Graph",
"tensorflow.python.ops.variable_scope.get_variable",
"tensorflow.python.ops.array_ops.placeholder",
"tensorflow.core.protobuf.config_pb2.RunMetadata",
"tensorflow.python.ops.math_ops.matmul",
"tensorflow.python.ops.math_ops.greater",
"tensorflow.python.framework.function._from_library",
"tensorflow.python.ops.init_ops.zeros_initializer",
"tensorflow.python.client.session.Session",
"tensorflow.core.framework.function_pb2.FunctionDefLibrary",
"numpy.random.rand",
"numpy.linspace",
"tensorflow.python.ops.random_ops.random_uniform",
"tensorflow.python.framework.ops.device",
"tensorflow.python.ops.array_ops.unstack",
"tensorflow.python.ops.control_flow_ops.Assert",
"numpy.random.uniform",
"tensorflow.core.protobuf.rewriter_config_pb2.RewriterConfig",
"tensorflow.python.platform.tf_logging.info",
"tensorflow.python.ops.math_ops.square",
"tensorflow.python.ops.linalg_ops.svd",
"tensorflow.python.ops.math_ops.minimum",
"numpy.zeros",
"tensorflow.python.ops.array_ops.identity",
"tensorflow.python.ops.math_ops.reduce_sum",
"tensorflow.python.ops.array_ops.zeros",
"tensorflow.python.ops.nn_ops.softmax",
"numpy.sinh",
"tensorflow.python.ops.variables.global_variables_initializer",
"tensorflow.python.ops.array_ops.shape",
"tensorflow.python.ops.control_flow_ops.while_loop",
"tensorflow.python.framework.ops.control_dependencies",
"tensorflow.python.ops.math_ops.reduce_mean",
"tensorflow.python.ops.math_ops.cast",
"tensorflow.python.ops.functional_ops.symbolic_gradient",
"tensorflow.python.ops.logging_ops.Print",
"tensorflow.python.ops.random_ops.random_normal",
"tensorflow.python.ops.control_flow_ops.cond",
"tensorflow.core.framework.function_pb2.FunctionDef.FromString",
"tensorflow.python.framework.function.get_extra_args",
"tensorflow.python.ops.variables.Variable",
"tensorflow.python.framework.function.get_extra_vars",
"tensorflow.python.ops.math_ops.divide",
"tensorflow.python.ops.init_ops.ones_initializer",
"tensorflow.python.framework.ops.get_default_graph",
"tensorflow.python.ops.array_ops.zeros_like",
"tensorflow.python.ops.math_ops.sigmoid",
"tensorflow.python.ops.math_ops.log",
"tensorflow.python.ops.array_ops.guarantee_const",
"numpy.exp",
"tensorflow.python.platform.test.main",
"tensorflow.python.framework.ops.name_scope",
"tensorflow.python.ops.array_ops.stack",
"tensorflow.python.ops.variables.global_variables",
"tensorflow.python.framework.function.Defun",
"tensorflow.python.ops.array_ops.concat",
"numpy.array",
"tensorflow.python.ops.math_ops.less_equal",
"tensorflow.python.ops.control_flow_ops.no_op",
"tensorflow.python.ops.math_ops.exp",
"tensorflow.python.ops.array_ops.transpose"
]
] |
kmakeev/RLs | [
"c47e9b504db157731c26d7c881719a4fb54cc355"
] | [
"mlagents/trainers/tests/test_ghost.py"
] | [
"import pytest\n\nimport numpy as np\n\nimport yaml\n\nfrom mlagents.trainers.ghost.trainer import GhostTrainer\nfrom mlagents.trainers.ghost.controller import GhostController\nfrom mlagents.trainers.behavior_id_utils import BehaviorIdentifiers\nfrom mlagents.trainers.ppo.trainer import PPOTrainer\nfrom mlagents.trainers.brain import BrainParameters\nfrom mlagents.trainers.agent_processor import AgentManagerQueue\nfrom mlagents.trainers.tests import mock_brain as mb\nfrom mlagents.trainers.tests.test_trajectory import make_fake_trajectory\n\n\[email protected]\ndef dummy_config():\n return yaml.safe_load(\n \"\"\"\n trainer: ppo\n batch_size: 32\n beta: 5.0e-3\n buffer_size: 512\n epsilon: 0.2\n hidden_units: 128\n lambd: 0.95\n learning_rate: 3.0e-4\n max_steps: 5.0e4\n normalize: true\n num_epoch: 5\n num_layers: 2\n time_horizon: 64\n sequence_length: 64\n summary_freq: 1000\n use_recurrent: false\n normalize: true\n memory_size: 8\n curiosity_strength: 0.0\n curiosity_enc_size: 1\n summary_path: test\n model_path: test\n reward_signals:\n extrinsic:\n strength: 1.0\n gamma: 0.99\n self_play:\n window: 5\n play_against_current_self_ratio: 0.5\n save_steps: 1000\n swap_steps: 1000\n \"\"\"\n )\n\n\nVECTOR_ACTION_SPACE = [1]\nVECTOR_OBS_SPACE = 8\nDISCRETE_ACTION_SPACE = [3, 3, 3, 2]\nBUFFER_INIT_SAMPLES = 513\nNUM_AGENTS = 12\n\n\[email protected](\"use_discrete\", [True, False])\ndef test_load_and_set(dummy_config, use_discrete):\n mock_brain = mb.setup_mock_brain(\n use_discrete,\n False,\n vector_action_space=VECTOR_ACTION_SPACE,\n vector_obs_space=VECTOR_OBS_SPACE,\n discrete_action_space=DISCRETE_ACTION_SPACE,\n )\n\n trainer_params = dummy_config\n trainer = PPOTrainer(mock_brain.brain_name, 0, trainer_params, True, False, 0, \"0\")\n trainer.seed = 1\n policy = trainer.create_policy(mock_brain.brain_name, mock_brain)\n policy.create_tf_graph()\n trainer.seed = 20 # otherwise graphs are the same\n to_load_policy = trainer.create_policy(mock_brain.brain_name, mock_brain)\n to_load_policy.create_tf_graph()\n to_load_policy.init_load_weights()\n\n weights = policy.get_weights()\n load_weights = to_load_policy.get_weights()\n try:\n for w, lw in zip(weights, load_weights):\n np.testing.assert_array_equal(w, lw)\n except AssertionError:\n pass\n\n to_load_policy.load_weights(weights)\n load_weights = to_load_policy.get_weights()\n\n for w, lw in zip(weights, load_weights):\n np.testing.assert_array_equal(w, lw)\n\n\ndef test_process_trajectory(dummy_config):\n brain_params_team0 = BrainParameters(\n brain_name=\"test_brain?team=0\",\n vector_observation_space_size=1,\n camera_resolutions=[],\n vector_action_space_size=[2],\n vector_action_descriptions=[],\n vector_action_space_type=0,\n )\n\n brain_name = BehaviorIdentifiers.from_name_behavior_id(\n brain_params_team0.brain_name\n ).brain_name\n\n brain_params_team1 = BrainParameters(\n brain_name=\"test_brain?team=1\",\n vector_observation_space_size=1,\n camera_resolutions=[],\n vector_action_space_size=[2],\n vector_action_descriptions=[],\n vector_action_space_type=0,\n )\n dummy_config[\"summary_path\"] = \"./summaries/test_trainer_summary\"\n dummy_config[\"model_path\"] = \"./models/test_trainer_models/TestModel\"\n ppo_trainer = PPOTrainer(brain_name, 0, dummy_config, True, False, 0, \"0\")\n controller = GhostController(100)\n trainer = GhostTrainer(\n ppo_trainer, brain_name, controller, 0, dummy_config, True, \"0\"\n )\n\n # first policy encountered becomes policy trained by wrapped PPO\n parsed_behavior_id0 = BehaviorIdentifiers.from_name_behavior_id(\n brain_params_team0.brain_name\n )\n policy = trainer.create_policy(parsed_behavior_id0, brain_params_team0)\n trainer.add_policy(parsed_behavior_id0, policy)\n trajectory_queue0 = AgentManagerQueue(brain_params_team0.brain_name)\n trainer.subscribe_trajectory_queue(trajectory_queue0)\n\n # Ghost trainer should ignore this queue because off policy\n parsed_behavior_id1 = BehaviorIdentifiers.from_name_behavior_id(\n brain_params_team1.brain_name\n )\n policy = trainer.create_policy(parsed_behavior_id1, brain_params_team1)\n trainer.add_policy(parsed_behavior_id1, policy)\n trajectory_queue1 = AgentManagerQueue(brain_params_team1.brain_name)\n trainer.subscribe_trajectory_queue(trajectory_queue1)\n\n time_horizon = 15\n trajectory = make_fake_trajectory(\n length=time_horizon,\n max_step_complete=True,\n vec_obs_size=1,\n num_vis_obs=0,\n action_space=[2],\n )\n trajectory_queue0.put(trajectory)\n trainer.advance()\n\n # Check that trainer put trajectory in update buffer\n assert trainer.trainer.update_buffer.num_experiences == 15\n\n trajectory_queue1.put(trajectory)\n trainer.advance()\n\n # Check that ghost trainer ignored off policy queue\n assert trainer.trainer.update_buffer.num_experiences == 15\n # Check that it emptied the queue\n assert trajectory_queue1.empty()\n\n\ndef test_publish_queue(dummy_config):\n brain_params_team0 = BrainParameters(\n brain_name=\"test_brain?team=0\",\n vector_observation_space_size=8,\n camera_resolutions=[],\n vector_action_space_size=[1],\n vector_action_descriptions=[],\n vector_action_space_type=0,\n )\n\n parsed_behavior_id0 = BehaviorIdentifiers.from_name_behavior_id(\n brain_params_team0.brain_name\n )\n\n brain_name = parsed_behavior_id0.brain_name\n\n brain_params_team1 = BrainParameters(\n brain_name=\"test_brain?team=1\",\n vector_observation_space_size=8,\n camera_resolutions=[],\n vector_action_space_size=[1],\n vector_action_descriptions=[],\n vector_action_space_type=0,\n )\n dummy_config[\"summary_path\"] = \"./summaries/test_trainer_summary\"\n dummy_config[\"model_path\"] = \"./models/test_trainer_models/TestModel\"\n ppo_trainer = PPOTrainer(brain_name, 0, dummy_config, True, False, 0, \"0\")\n controller = GhostController(100)\n trainer = GhostTrainer(\n ppo_trainer, brain_name, controller, 0, dummy_config, True, \"0\"\n )\n\n # First policy encountered becomes policy trained by wrapped PPO\n # This queue should remain empty after swap snapshot\n policy = trainer.create_policy(parsed_behavior_id0, brain_params_team0)\n trainer.add_policy(parsed_behavior_id0, policy)\n policy_queue0 = AgentManagerQueue(brain_params_team0.brain_name)\n trainer.publish_policy_queue(policy_queue0)\n\n # Ghost trainer should use this queue for ghost policy swap\n parsed_behavior_id1 = BehaviorIdentifiers.from_name_behavior_id(\n brain_params_team1.brain_name\n )\n policy = trainer.create_policy(parsed_behavior_id1, brain_params_team1)\n trainer.add_policy(parsed_behavior_id1, policy)\n policy_queue1 = AgentManagerQueue(brain_params_team1.brain_name)\n trainer.publish_policy_queue(policy_queue1)\n\n # check ghost trainer swap pushes to ghost queue and not trainer\n assert policy_queue0.empty() and policy_queue1.empty()\n trainer._swap_snapshots()\n assert policy_queue0.empty() and not policy_queue1.empty()\n # clear\n policy_queue1.get_nowait()\n\n mock_brain = mb.setup_mock_brain(\n False,\n False,\n vector_action_space=VECTOR_ACTION_SPACE,\n vector_obs_space=VECTOR_OBS_SPACE,\n discrete_action_space=DISCRETE_ACTION_SPACE,\n )\n\n buffer = mb.simulate_rollout(BUFFER_INIT_SAMPLES, mock_brain)\n # Mock out reward signal eval\n buffer[\"extrinsic_rewards\"] = buffer[\"environment_rewards\"]\n buffer[\"extrinsic_returns\"] = buffer[\"environment_rewards\"]\n buffer[\"extrinsic_value_estimates\"] = buffer[\"environment_rewards\"]\n buffer[\"curiosity_rewards\"] = buffer[\"environment_rewards\"]\n buffer[\"curiosity_returns\"] = buffer[\"environment_rewards\"]\n buffer[\"curiosity_value_estimates\"] = buffer[\"environment_rewards\"]\n buffer[\"advantages\"] = buffer[\"environment_rewards\"]\n trainer.trainer.update_buffer = buffer\n\n # when ghost trainer advance and wrapped trainer buffers full\n # the wrapped trainer pushes updated policy to correct queue\n assert policy_queue0.empty() and policy_queue1.empty()\n trainer.advance()\n assert not policy_queue0.empty() and policy_queue1.empty()\n\n\nif __name__ == \"__main__\":\n pytest.main()\n"
] | [
[
"numpy.testing.assert_array_equal"
]
] |
abdolence/analytics-zoo | [
"364856abcbe9aff7f7b6cf9b9f8648d51e07ca64",
"364856abcbe9aff7f7b6cf9b9f8648d51e07ca64"
] | [
"pyzoo/zoo/util/tf_graph_util.py",
"pyzoo/zoo/examples/anomalydetection/anomaly_detection.py"
] | [
"# This file is adapted from https://github.com/tensorflow/tensorflow/blob/master\n# /tensorflow/python/framework/graph_util_impl.py\n#\n# Copyright 2015 The TensorFlow Authors, 2019 Analytics Zoo Authors.\n# 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\"\"\"Helpers to manipulate a tensor graph in python.\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nimport copy\nimport re\nimport six\n\nfrom tensorflow.core.framework import attr_value_pb2\nfrom tensorflow.core.framework import graph_pb2\nfrom tensorflow.core.framework import node_def_pb2\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import tensor_util\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util.tf_export import tf_export\n\n_VARIABLE_OPS = {\n \"Assign\",\n \"AssignAdd\",\n \"AssignSub\",\n \"Queue\",\n \"ScatterAdd\",\n \"ScatterSub\",\n \"ScatterUpdate\",\n \"TruncatedNormal\",\n \"Variable\",\n \"VariableV2\",\n}\n\n\ndef _is_variable_op(op):\n \"\"\"Returns true if 'op' refers to a Variable node.\"\"\"\n return op in _VARIABLE_OPS\n\n\[email protected](\n date=None,\n instructions=\"Use `tf.compat.v1.graph_util.must_run_on_cpu`\")\n@tf_export(v1=[\"graph_util.must_run_on_cpu\"])\ndef must_run_on_cpu(node, pin_variables_on_cpu=False):\n \"\"\"Returns True if the given node_def must run on CPU, otherwise False.\n Args:\n node: The node to be assigned to a device. Could be either an ops.Operation\n or NodeDef.\n pin_variables_on_cpu: If True, this function will return False if node_def\n represents a variable-related op.\n Returns:\n True if the given node must run on CPU, otherwise False.\n \"\"\"\n\n if isinstance(node, ops.Operation):\n node_def = node.node_def\n else:\n assert isinstance(node, node_def_pb2.NodeDef)\n node_def = node\n\n # If the op is a variable-related op, should we pin it on CPU?\n if pin_variables_on_cpu and _is_variable_op(node_def.op):\n return True\n\n # Constant operations producing a string or int32 must run on CPU.\n if node_def.op == \"Const\":\n # Get the value of the 'dtype' attr\n dtype = node_def.attr[\"dtype\"].type\n if dtype == dtypes.string or dtype == dtypes.int32:\n return True\n\n if node_def.op in [\"DynamicStitch\", \"ParallelDynamicStitch\"]:\n dtype = node_def.attr[\"T\"].type\n if dtype == dtypes.int32:\n # DynamicStitch on GPU only works for int32 values.\n return True\n\n if node_def.op in [\"Cast\"]:\n dtype = node_def.attr[\"SrcT\"].type\n if dtype == dtypes.int32:\n # Cast on GPU does not works for int32 values.\n return True\n return False\n\n\n################################################################################\n#\n# device functions for use in with g.device(...)\n#\n################################################################################\n\n\ndef _node_name(n):\n if n.startswith(\"^\"):\n return n[1:]\n else:\n return n.split(\":\")[0]\n\n\ndef _extract_graph_summary(graph_def):\n \"\"\"Extracts useful information from the graph and returns them.\"\"\"\n name_to_input_name = {} # Keyed by the dest node name.\n name_to_node = {} # Keyed by node name.\n\n # Keeps track of node sequences. It is important to still output the\n # operations in the original order.\n name_to_seq_num = {} # Keyed by node name.\n seq = 0\n for node in graph_def.node:\n n = _node_name(node.name)\n name_to_node[n] = node\n name_to_input_name[n] = [_node_name(x) for x in node.input]\n if \"_class\" in node.attr:\n for v in node.attr[\"_class\"].list.s:\n v_str = v.decode(\"utf-8\")\n if v_str.startswith(\"loc:@\"):\n colocated_node = v_str[5:]\n name_to_input_name[n].append(colocated_node)\n name_to_seq_num[n] = seq\n seq += 1\n return name_to_input_name, name_to_node, name_to_seq_num\n\n\ndef _assert_nodes_are_present(name_to_node, nodes):\n \"\"\"Assert that nodes are present in the graph.\"\"\"\n for d in nodes:\n assert d in name_to_node, \"%s is not in graph\" % d\n\n\ndef _bfs_for_reachable_nodes(target_nodes, name_to_input_name):\n \"\"\"Breadth first search for reachable nodes from target nodes.\"\"\"\n nodes_to_keep = set()\n # Breadth first search to find all the nodes that we should keep.\n next_to_visit = target_nodes[:]\n while next_to_visit:\n node = next_to_visit[0]\n del next_to_visit[0]\n if node in nodes_to_keep:\n # Already visited this node.\n continue\n nodes_to_keep.add(node)\n if node in name_to_input_name:\n next_to_visit += name_to_input_name[node]\n return nodes_to_keep\n\n\[email protected](\n date=None,\n instructions=\"Use `tf.compat.v1.graph_util.extract_sub_graph`\")\n@tf_export(v1=[\"graph_util.extract_sub_graph\"])\ndef extract_sub_graph(graph_def, dest_nodes):\n \"\"\"Extract the subgraph that can reach any of the nodes in 'dest_nodes'.\n Args:\n graph_def: A graph_pb2.GraphDef proto.\n dest_nodes: A list of strings specifying the destination node names.\n Returns:\n The GraphDef of the sub-graph.\n Raises:\n TypeError: If 'graph_def' is not a graph_pb2.GraphDef proto.\n \"\"\"\n\n if not isinstance(graph_def, graph_pb2.GraphDef):\n raise TypeError(\"graph_def must be a graph_pb2.GraphDef proto.\")\n\n if isinstance(dest_nodes, six.string_types):\n raise TypeError(\"dest_nodes must be a list.\")\n\n name_to_input_name, name_to_node, name_to_seq_num = _extract_graph_summary(\n graph_def)\n _assert_nodes_are_present(name_to_node, dest_nodes)\n\n nodes_to_keep = _bfs_for_reachable_nodes(dest_nodes, name_to_input_name)\n\n nodes_to_keep_list = sorted(\n list(nodes_to_keep), key=lambda n: name_to_seq_num[n])\n # Now construct the output GraphDef\n out = graph_pb2.GraphDef()\n for n in nodes_to_keep_list:\n out.node.extend([copy.deepcopy(name_to_node[n])])\n out.library.CopyFrom(graph_def.library)\n out.versions.CopyFrom(graph_def.versions)\n\n return out\n\n\[email protected](\n date=None,\n instructions=\"Use `tf.compat.v1.graph_util.tensor_shape_from_node_def_name`\"\n)\n@tf_export(v1=[\"graph_util.tensor_shape_from_node_def_name\"])\ndef tensor_shape_from_node_def_name(graph, input_name):\n \"\"\"Convenience function to get a shape from a NodeDef's input string.\"\"\"\n # To get a tensor, the name must be in the form <input>:<port>, for example\n # 'Mul:0'. The GraphDef input strings don't always have the port specified\n # though, so if there isn't a colon we need to add a default ':0' to the end.\n if \":\" not in input_name:\n canonical_name = input_name + \":0\"\n else:\n canonical_name = input_name\n tensor = graph.get_tensor_by_name(canonical_name)\n shape = tensor.get_shape()\n return shape\n\n\[email protected](\n date=None,\n instructions=\"Use `tf.compat.v1.graph_util.convert_variables_to_constants`\")\n@tf_export(v1=[\"graph_util.convert_variables_to_constants\"])\ndef convert_variables_to_constants(sess,\n input_graph_def,\n output_node_names,\n variable_names_whitelist=None,\n variable_names_blacklist=None):\n \"\"\"Replaces all the variables in a graph with constants of the same values.\n If you have a trained graph containing Variable ops, it can be convenient to\n convert them all to Const ops holding the same values. This makes it possible\n to describe the network fully with a single GraphDef file, and allows the\n removal of a lot of ops related to loading and saving the variables.\n Args:\n sess: Active TensorFlow session containing the variables.\n input_graph_def: GraphDef object holding the network.\n output_node_names: List of name strings for the result nodes of the graph.\n variable_names_whitelist: The set of variable names to convert (by default,\n all variables are converted).\n variable_names_blacklist: The set of variable names to omit converting\n to constants.\n Returns:\n GraphDef containing a simplified version of the original.\n \"\"\"\n\n def has_variable_as_input(node):\n \"\"\"Checks if the input node has a variable in `variables_data_map`.\"\"\"\n for name in node.input:\n if name in variables_data_map or\\\n (name in identity_ops_input_map\n and identity_ops_input_map[name] in variables_data_map):\n return True\n return False\n\n def dfs_find_variable(origin_name, name_to_nodes):\n\n if origin_name in variables_data_map:\n return origin_name, set()\n\n nodes_in_path = set()\n found_variables = set()\n\n def dfs(name):\n node = name_to_nodes[name]\n if node.op == \"Switch\":\n inputs = [node.input[0]]\n else:\n inputs = node.input\n for name in inputs:\n name = _node_name(name)\n if name in nodes_in_path:\n continue\n elif name in variables_data_map:\n found_variables.add(name)\n continue\n else:\n nodes_in_path.add(name)\n dfs(name)\n\n nodes_in_path.add(origin_name)\n dfs(origin_name)\n\n if len(found_variables) > 1:\n raise ValueError(\"found variables %s\" % found_variables)\n\n variable = None\n for v in found_variables:\n variable = v\n return variable, nodes_in_path\n\n def create_const_op(node_name, dtype, data, data_shape=None):\n \"\"\"Creates a Const op.\"\"\"\n output_node = node_def_pb2.NodeDef()\n output_node.op = \"Const\"\n output_node.name = node_name\n output_node.attr[\"dtype\"].CopyFrom(dtype)\n output_node.attr[\"value\"].CopyFrom(\n attr_value_pb2.AttrValue(\n tensor=tensor_util.make_tensor_proto(\n data, dtype=dtype.type, shape=data_shape)))\n return output_node\n\n # This graph only includes the nodes needed to evaluate the output nodes, and\n # removes unneeded nodes like those involved in saving and assignment.\n inference_graph = extract_sub_graph(input_graph_def, output_node_names)\n\n # Get list of variables.\n variable_names = []\n variable_dict_names = []\n identity_ops_input_map = {}\n name_to_node = {}\n for node in inference_graph.node:\n name_to_node[node.name] = node\n if node.op in [\"Variable\", \"VariableV2\", \"VarHandleOp\"]:\n variable_name = node.name\n if ((variable_names_whitelist is not None\n and variable_name not in variable_names_whitelist) or\n (variable_names_blacklist is not None\n and variable_name in variable_names_blacklist)):\n continue\n variable_dict_names.append(variable_name)\n if node.op == \"VarHandleOp\":\n variable_names.append(variable_name + \"/Read/ReadVariableOp:0\")\n else:\n variable_names.append(variable_name + \":0\")\n elif node.op == \"Identity\":\n # TODO(nupurgarg): Move and reuse get_name from lite/convert.py.\n # Creates a map of Identity node names to the input names.\n input_info = node.input[0].split(\":\")\n if (len(input_info) == 1 or\n (len(input_info) == 2 and int(input_info[1]) == 0)):\n identity_ops_input_map[node.name] = input_info[0]\n\n # Gets map of variables and the associated data.\n if variable_names:\n returned_variables = sess.run(variable_names)\n else:\n returned_variables = []\n variables_data_map = dict(zip(variable_dict_names, returned_variables))\n logging.info(\"Froze %d variables.\", len(returned_variables))\n\n # Reconstruct the graph with constants in place of variables.\n\n path_node_to_variables = {}\n output_graph_def = graph_pb2.GraphDef()\n how_many_converted = 0\n for input_node in inference_graph.node:\n output_node = node_def_pb2.NodeDef()\n if input_node.name in variables_data_map:\n data = variables_data_map[input_node.name]\n output_node = create_const_op(input_node.name, input_node.attr[\"dtype\"],\n data, data.shape)\n how_many_converted += 1\n elif input_node.op == \"ReadVariableOp\":\n variable, nodes_in_path = dfs_find_variable(input_node.input[0], name_to_node)\n if variable is not None:\n # The first branch converts all VarHandleOps of ResourceVariables to\n # constants, so we need to convert the associated ReadVariableOps to\n # Identity ops.\n #\n # Handles the following cases:\n # Variable --> ReadVariableOp\n # Variable --> Identity --> ReadVariableOp\n output_node.op = \"Identity\"\n output_node.name = input_node.name\n output_node.input.extend([input_node.input[0]])\n output_node.attr[\"T\"].CopyFrom(input_node.attr[\"dtype\"])\n if \"_class\" in input_node.attr:\n output_node.attr[\"_class\"].CopyFrom(input_node.attr[\"_class\"])\n for name in nodes_in_path:\n path_node_to_variables[name] = variable\n else:\n raise ValueError(\"Cannot find variable for %s\" % input_node.name)\n\n elif input_node.op == \"ResourceGather\":\n\n variable, nodes_in_path = dfs_find_variable(input_node.input[0], name_to_node)\n if variable is not None:\n # The first branch converts all VarHandleOps of ResourceGather to\n # constants, so we need to convert the associated ResourceGather to Gather\n # ops with a Const axis feeding into it.\n if input_node.attr[\"batch_dims\"].i != 0:\n raise ValueError(\"batch_dims != 0 is not supported by freeze_graph.\")\n axis_data = input_node.attr[\"batch_dims\"].i\n axis_node_name = input_node.name + \"/axis\"\n axis_dtype = input_node.attr[\"Tindices\"]\n output_axis_node = create_const_op(axis_node_name, axis_dtype, axis_data)\n output_graph_def.node.extend([output_axis_node])\n\n output_node.op = \"GatherV2\"\n output_node.name = input_node.name\n output_node.input.extend(\n [input_node.input[0], input_node.input[1], axis_node_name])\n output_node.attr[\"Tparams\"].CopyFrom(input_node.attr[\"dtype\"])\n output_node.attr[\"Tindices\"].CopyFrom(input_node.attr[\"Tindices\"])\n output_node.attr[\"Taxis\"].CopyFrom(axis_dtype)\n if \"_class\" in input_node.attr:\n output_node.attr[\"_class\"].CopyFrom(input_node.attr[\"_class\"])\n for name in nodes_in_path:\n path_node_to_variables[name] = variable\n else:\n raise ValueError(\"Cannot find variable for %s\" % input_node.name)\n elif input_node.op == \"VariableShape\":\n\n variable, nodes_in_path = dfs_find_variable(input_node.input[0], name_to_node)\n if variable is not None:\n input_variable = name_to_node[variable]\n output_node.op = \"Shape\"\n output_node.name = input_node.name\n output_node.input.extend([input_node.input[0]])\n output_node.attr[\"T\"].CopyFrom(input_variable.attr[\"dtype\"])\n output_node.attr[\"out_type\"].CopyFrom(input_node.attr[\"out_type\"])\n for name in nodes_in_path:\n path_node_to_variables[name] = variable\n else:\n raise ValueError(\"Cannot find variable for %s\" % input_node.name)\n else:\n output_node.CopyFrom(input_node)\n output_graph_def.node.extend([output_node])\n\n output_graph_def.library.CopyFrom(inference_graph.library)\n\n inference_graph = output_graph_def\n output_graph_def = graph_pb2.GraphDef()\n for input_node in inference_graph.node:\n output_node = node_def_pb2.NodeDef()\n if input_node.name in path_node_to_variables:\n input_variable = path_node_to_variables[input_node.name]\n input_variable = name_to_node[input_variable]\n output_node.op = input_node.op\n output_node.name = input_node.name\n if input_node.op == \"Enter\":\n output_node.input.extend([input_node.input[0]])\n output_node.attr[\"T\"].CopyFrom(input_variable.attr[\"dtype\"])\n output_node.attr[\"frame_name\"].CopyFrom(input_node.attr[\"frame_name\"])\n output_node.attr[\"is_constant\"].CopyFrom(input_node.attr[\"is_constant\"])\n output_node.attr[\"parallel_iterations\"]\\\n .CopyFrom(input_node.attr[\"parallel_iterations\"])\n elif input_node.op == \"Switch\":\n output_node.input.extend(input_node.input)\n output_node.attr[\"T\"].CopyFrom(input_variable.attr[\"dtype\"])\n else:\n raise ValueError(\"cannot do type: %s\" % input_node.op)\n else:\n output_node.CopyFrom(input_node)\n output_graph_def.node.extend([output_node])\n\n output_graph_def.library.CopyFrom(inference_graph.library)\n\n logging.info(\"Converted %d variables to const ops.\", how_many_converted)\n return output_graph_def\n\n\[email protected](\n date=None,\n instructions=\"Use `tf.compat.v1.graph_util.remove_training_nodes`\")\n@tf_export(v1=[\"graph_util.remove_training_nodes\"])\ndef remove_training_nodes(input_graph, protected_nodes=None):\n \"\"\"Prunes out nodes that aren't needed for inference.\n There are nodes like Identity and CheckNumerics that are only useful\n during training, and can be removed in graphs that will be used for\n nothing but inference. Here we identify and remove them, returning an\n equivalent graph. To be specific, CheckNumerics nodes are always removed, and\n Identity nodes that aren't involved in control edges are spliced out so that\n their input and outputs are directly connected.\n Args:\n input_graph: Model to analyze and prune.\n protected_nodes: An optional list of names of nodes to be kept\n unconditionally. This is for example useful to preserve Identity output\n nodes.\n Returns:\n A list of nodes with the unnecessary ones removed.\n \"\"\"\n if not protected_nodes:\n protected_nodes = []\n\n types_to_remove = {\"CheckNumerics\": True}\n\n input_nodes = input_graph.node\n names_to_remove = {}\n for node in input_nodes:\n if node.op in types_to_remove and node.name not in protected_nodes:\n names_to_remove[node.name] = True\n\n nodes_after_removal = []\n for node in input_nodes:\n if node.name in names_to_remove:\n continue\n new_node = node_def_pb2.NodeDef()\n new_node.CopyFrom(node)\n input_before_removal = node.input\n del new_node.input[:]\n for full_input_name in input_before_removal:\n input_name = re.sub(r\"^\\^\", \"\", full_input_name)\n if input_name in names_to_remove:\n continue\n new_node.input.append(full_input_name)\n nodes_after_removal.append(new_node)\n\n types_to_splice = {\"Identity\": True}\n control_input_names = set()\n node_names_with_control_input = set()\n for node in nodes_after_removal:\n for node_input in node.input:\n if \"^\" in node_input:\n control_input_names.add(node_input.replace(\"^\", \"\"))\n node_names_with_control_input.add(node.name)\n\n names_to_splice = {}\n for node in nodes_after_removal:\n if node.op in types_to_splice and node.name not in protected_nodes:\n # We don't want to remove nodes that have control edge inputs, because\n # they might be involved in subtle dependency issues that removing them\n # will jeopardize.\n if node.name not in node_names_with_control_input:\n names_to_splice[node.name] = node.input[0]\n\n # We also don't want to remove nodes which are used as control edge inputs.\n names_to_splice = {name: value for name, value in names_to_splice.items()\n if name not in control_input_names}\n\n nodes_after_splicing = []\n for node in nodes_after_removal:\n if node.name in names_to_splice:\n continue\n new_node = node_def_pb2.NodeDef()\n new_node.CopyFrom(node)\n input_before_removal = node.input\n del new_node.input[:]\n for full_input_name in input_before_removal:\n input_name = re.sub(r\"^\\^\", \"\", full_input_name)\n while input_name in names_to_splice:\n full_input_name = names_to_splice[input_name]\n input_name = re.sub(r\"^\\^\", \"\", full_input_name)\n new_node.input.append(full_input_name)\n nodes_after_splicing.append(new_node)\n\n output_graph = graph_pb2.GraphDef()\n output_graph.node.extend(nodes_after_splicing)\n return output_graph\n",
"#\n# Copyright 2018 Analytics Zoo 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\nfrom zoo.common.nncontext import init_nncontext\nfrom zoo.models.anomalydetection import AnomalyDetector\nimport pandas as pd\nfrom pyspark.sql import SQLContext\nfrom pyspark import sql\nfrom optparse import OptionParser\nimport sys\n\nif __name__ == \"__main__\":\n parser = OptionParser()\n parser.add_option(\"--input_dir\", dest=\"input_dir\")\n parser.add_option(\"-b\", \"--batch_size\", dest=\"batch_size\", default=\"1024\")\n parser.add_option(\"--nb_epoch\", dest=\"nb_epoch\", default=\"20\")\n parser.add_option(\"--unroll_len\", dest=\"unroll_len\", default=\"24\")\n\n (options, args) = parser.parse_args(sys.argv)\n sc = init_nncontext(\"Anomaly Detection Example\")\n\n sqlContext = sql.SQLContext(sc)\n\n def load_and_scale(input_path):\n df = pd.read_csv(input_path)\n df['datetime'] = pd.to_datetime(df['timestamp'])\n df['hours'] = df['datetime'].dt.hour\n df['awake'] = (((df['hours'] >= 6) & (df['hours'] <= 23)) | (df['hours'] == 0)).astype(int)\n print(df.head(10))\n sqlContext = SQLContext(sc)\n dfspark = sqlContext.createDataFrame(df[[\"value\", \"hours\", \"awake\"]])\n feature_size = len([\"value\", \"hours\", \"awake\"])\n return AnomalyDetector.standardScale(dfspark), feature_size\n\n dfscaled, feature_size = load_and_scale(options.input_dir)\n datardd = dfscaled.rdd.map(lambda row: [x for x in row])\n unrolled = AnomalyDetector.unroll(datardd, int(options.unroll_len), predict_step=1)\n [train, test] = AnomalyDetector.train_test_split(unrolled, 1000)\n\n model = AnomalyDetector(feature_shape=(int(options.unroll_len), feature_size),\n hidden_layers=[8, 32, 15], dropouts=[0.2, 0.2, 0.2])\n model.compile(loss='mse', optimizer='rmsprop', metrics=['mae'])\n model.fit(train, batch_size=int(options.batch_size), nb_epoch=int(options.nb_epoch),\n validation_data=test)\n test.cache()\n y_predict = model.predict(test).map(lambda x: float(x[0]))\n y_truth = test.map(lambda x: float(x.label.to_ndarray()[0]))\n anomalies = AnomalyDetector.detect_anomalies(y_predict, y_truth, 50)\n\n print(anomalies.take(10)[0:10])\n"
] | [
[
"tensorflow.python.util.deprecation.deprecated",
"tensorflow.python.platform.tf_logging.info",
"tensorflow.python.util.tf_export.tf_export",
"tensorflow.core.framework.node_def_pb2.NodeDef",
"tensorflow.python.framework.tensor_util.make_tensor_proto",
"tensorflow.core.framework.graph_pb2.GraphDef"
],
[
"pandas.read_csv",
"pandas.to_datetime"
]
] |
uzck/tf_net_parser | [
"5e9da1e8a317ef24c2f1577a56d6445e432b1f5d"
] | [
"utils.py"
] | [
"import os\nimport numpy as np \nimport matplotlib.image as mpimg\nimport matplotlib.pyplot as plt\nimport cv2\nimport tensorflow as tf\nfrom PIL import Image\n\ndef image_to_ndarray(image_path: str) -> np.ndarray:\n \"\"\"\n Args:\n image_path: 图片文件路径\n \"\"\"\n pass\n\ndef read_image(image_path: str):\n \"\"\"\n 读取图片\n \"\"\"\n if not os.path.exists(image_path):\n print('图片文件路径出错')\n image = mpimg.imread(image_path) # type: np.ndarray\n print(np.shape(image))\n return image\n\ndef show_image(image: np.ndarray):\n \"\"\"\n 显示图片\n \"\"\"\n plt.imshow(image)\n plt.show() \n\ndef save_image(target_path: str, image: np.ndarray):\n cv2.imwrite(target_path, image)\n # image = Image.fromarray(image * 255)\n # image = image.convert('RGB')\n # image.save(target_path)\n\ndef padding(origin: np.ndarray, padding_size, value=0):\n \"\"\"\n 填充图片\n \"\"\"\n return np.pad(origin, padding_size, 'constant')\n\ndef fix_pad_tensor(inputs, kernel_size, data_format='channels_last'):\n pad_total = kernel_size - 1\n pad_beg = pad_total // 2\n pad_end = pad_total - pad_beg\n\n if data_format == 'channels_first':\n padded_inputs = tf.pad(tensor=inputs,\n paddings=[[0, 0], [0, 0], [pad_beg, pad_end],\n [pad_beg, pad_end]])\n else:\n padded_inputs = tf.pad(tensor=inputs,\n paddings=[[0, 0], [pad_beg, pad_end],\n [pad_beg, pad_end], [0, 0]])\n return padded_inputs\n\ndef restore_graph(file_path: str, sess: tf.Session):\n \"\"\"\n 加载图模型\n \"\"\"\n saver = tf.train.Saver(max_to_keep=5)\n return saver.restore(sess, tf.train.latest_checkpoint('../save_model/'))\ndef save_model(file_path: str, sess: tf.Session, gloabl_step=100, max_model_count=5, keep_checkpoint_every_n_hours=0.5, write_meta_graph=False):\n \"\"\"\n 存储训练模型到指定路径\n \"\"\"\n saver = tf.train.Saver(max_to_keep=max_model_count, keep_checkpoint_every_n_hours=keep_checkpoint_every_n_hours) # type: tf.train.Saver\n saver.save(sess, file_path, global_step=gloabl_step, write_meta_graph=write_meta_graph)\n\ndef load_weigths_npz(file_path: str):\n \"\"\"\n 读取npz格式存储的权重文件\n \"\"\"\n npz_file = np.load(file_path)\n return npz_file\n\ndef save_to_npy(file_path:str, target):\n \"\"\"\n 存储指定的图或者权重变量到npy文件\n \"\"\"\n np.save(file_path, target)\n\ndef save_to_npz(file_path: str, target):\n np.savez(file_path, target)\n\ndef transfer_graph_to_network(graph):\n \"\"\"\n 把saver.restore重建的图解析成Network类\n \"\"\"\n pass\n\ndef trans_ckpt_to_pb(ckpt_dir_path: str, save_path: str):\n pass"
] | [
[
"tensorflow.pad",
"numpy.load",
"numpy.save",
"numpy.savez",
"tensorflow.train.latest_checkpoint",
"matplotlib.pyplot.imshow",
"matplotlib.pyplot.show",
"numpy.shape",
"tensorflow.train.Saver",
"numpy.pad",
"matplotlib.image.imread"
]
] |
Kelvin-spacy/CogAlg | [
"e0f44a8746ba33a07864505d6e2ae959859024b0"
] | [
"frame_2D_alg/class_cluster.py"
] | [
"\"\"\"\nProvide a base class for cluster objects in CogAlg.\nFeatures:\n- Unique instance ids per class.\n- Instances are retrievable by ids via class.\n- Reduced memory usage compared to using dict.\n- Methods generated via string templates so overheads caused by\ndifferences in interfaces are mostly eliminated.\n- Can be extended/modified further to support main implementation better.\n\"\"\"\n\nimport weakref\nfrom numbers import Number\nfrom inspect import isclass\nimport numpy as np\n\nNoneType = type(None)\n\n# ----------------------------------------------------------------------------\n# Template for class method generation\n_methods_template = '''\n@property\ndef id(self):\n return self._id\n \ndef pack(self{pack_args}):\n \"\"\"Pack all fields/params back into {typename}.\"\"\"\n {pack_assignments}\n \ndef unpack(self):\n \"\"\"Unpack all fields/params back into the cluster.\"\"\"\n return ({param_vals})\ndef accumulate(self, **kwargs):\n \"\"\"Add a number to specified numerical fields/params.\"\"\"\n {accumulations}\ndef __contains__(self, item):\n return (item in {params})\ndef __delattr__(self, item):\n raise AttributeError(\"cannot delete attribute from \"\n \"'{typename}' object\")\ndef __repr__(self):\n return \"{typename}({repr_fmt})\" % ({numeric_param_vals})\n'''\n\n# ----------------------------------------------------------------------------\n# MetaCluster meta-class\nclass MetaCluster(type):\n \"\"\"\n Serve as a factory for creating new cluster classes.\n \"\"\"\n def __new__(mcs, typename, bases, attrs): # called right before a new class is created\n # get fields/params and numeric params\n replace = attrs.get('replace', {})\n\n # inherit params\n new_bases = []\n for base in bases:\n if issubclass(base, ClusterStructure):\n new_bases.append(base)\n for param in base.numeric_params:\n if param not in attrs: # prevents duplication of base params\n # not all inherited params are Cdm\n if param in replace:\n new_param, new_type = replace[param]\n if new_param is not None:\n attrs[new_param] = new_type\n else:\n attrs[param] = getattr(base,param+'_type') # if the param is not replaced, it will following type of base param\n else:\n print(f\"Warning: {base} is not a subclass of {ClusterStructure}\")\n\n bases = tuple(new_bases) # remove\n\n if len(bases)>1:\n bases=(bases[0],)\n\n # only ignore param names start with double underscore\n params = tuple(attr for attr in attrs\n if not attr.startswith('__') and\n isclass(attrs[attr]))\n\n numeric_params = tuple(param for param in params\n if (issubclass(attrs[param], Number)) and\n not (issubclass(attrs[param], bool))) # avoid accumulate bool, which is flag\n\n list_params = tuple(param for param in params\n if (issubclass(attrs[param], list)))\n\n dict_params = tuple(param for param in params\n if (issubclass(attrs[param], dict)))\n\n # Fill in the template\n methods_definitions = _methods_template.format(\n typename=typename,\n params=str(params),\n param_vals=', '.join(f'self.{param}'\n for param in params),\n numeric_param_vals=', '.join(f'self.{param}'\n for param in numeric_params),\n list_param_vals=', '.join(f'self.{param}'\n for param in list_params),\n dict_param_vals=', '.join(f'self.{param}'\n for param in dict_params),\n pack_args=', '.join(param for param in ('', *params)),\n pack_assignments='; '.join(f'self.{param} = {param}'\n for param in params)\n if params else 'pass',\n accumulations='; '.join(f\"self.{param} += \"\n f\"kwargs.get('{param}', 0)\"\n for param in numeric_params)\n if params else 'pass',\n repr_fmt=', '.join(f'{param}=%r' for param in numeric_params),\n )\n # Generate methods\n namespace = dict(print=print)\n exec(methods_definitions, namespace)\n # Replace irrelevant names\n namespace.pop('__builtins__')\n namespace.pop('print')\n\n # Update to attrs\n attrs.update(namespace)\n\n # Save default types for fields/params\n for param in params:\n attrs[param + '_type'] = attrs.pop(param)\n # attrs['params'] = params\n attrs['numeric_params'] = numeric_params\n attrs['list_params'] = list_params\n attrs['dict_params'] = dict_params\n\n # Add fields/params and other instance attributes\n attrs['__slots__'] = (('_id', 'hid', *params, '__weakref__')\n if not bases else ('_id', 'hid', *params))\n\n # Register the new class\n cls = super().__new__(mcs, typename, bases, attrs)\n\n # Create container for references to instances\n cls._instances = []\n\n return cls\n\n def __call__(cls, *args, **kwargs): # call right before a new instance is created\n # register new instance\n instance = super().__call__(*args, **kwargs)\n\n # initialize fields/params\n for param in cls.__slots__[2:]: # Exclude _id and __weakref__\n setattr(instance, param,\n kwargs.get(param,\n getattr(cls, param + '_type')()))\n\n # set inherited params\n if kwargs.get('inherit') is not None:\n\n excluded = []\n if kwargs.get('excluded') is not None:\n excluded = kwargs.get('excluded')\n\n for inherit_instance in kwargs.get('inherit'):\n for param in cls.numeric_params: # inherit numeric params\n if hasattr(inherit_instance,param) and (param not in excluded):\n setattr(instance, param, getattr(inherit_instance, param))\n\n for param in cls.list_params: # inherit list params\n if hasattr(inherit_instance,param) and (param not in excluded):\n list_param = getattr(inherit_instance, param)\n if len(list_param)>0: # not empty list\n setattr(instance, param, list_param )\n\n for param in cls.dict_params: # inherit dict params\n if hasattr(inherit_instance,param) and (param not in excluded):\n setattr(instance, param, getattr(inherit_instance, param))\n\n for param in cls.dict_params: # inherit dict params\n if hasattr(inherit_instance,param) and (param not in excluded):\n setattr(instance, param, getattr(inherit_instance, param))\n\n # Set id\n instance._id = len(cls._instances)\n # Create ref\n cls._instances.append(weakref.ref(instance))\n # no default higher cluster id, set to None\n instance.hid = None # higher cluster's id\n\n return instance\n\n # original\n '''\n def __call__(cls, *args, **kwargs): # call right before a new instance is created\n # register new instance\n instance = super().__call__(*args, **kwargs)\n # initialize fields/params\n for param in cls.__slots__[2:]: # Exclude _id and __weakref__\n setattr(instance, param,\n kwargs.get(param,\n getattr(cls, param + '_type')()))\n # Set id\n instance._id = len(cls._instances)\n # Create ref\n cls._instances.append(weakref.ref(instance))\n # no default higher cluster id, set to None\n instance.hid = None # higher cluster's id\n return instance\n '''\n\n def get_instance(cls, cluster_id):\n try:\n return cls._instances[cluster_id]()\n except IndexError:\n return None\n\n @property\n def instance_cnt(cls):\n return len(cls._instances)\n\n\n# ----------------------------------------------------------------------------\n# ClusterStructure class\nclass ClusterStructure(metaclass=MetaCluster):\n \"\"\"\n Class for cluster objects in CogAlg.\n Each time a new instance is created, four things are done:\n - Set initialize field/param.\n - Set id.\n - Save a weak reference of instance inside the class object.\n (meaning that if there's no other references to instance,\n it will be garbage collected, weakref to it will return None\n afterwards)\n - Set higher cluster id to None (no higher cluster structure yet)\n Examples\n --------\n >>> from class_cluster import ClusterStructure\n >>> class CP(ClusterStructure):\n >>> L = int # field/param name and default type\n >>> I = int\n >>>\n >>> P1 = CP(L=1, I=5) # initialized with values\n >>> print(P1)\n CP(L=1, I=5)\n >>> P2 = CP() # default initialization\n >>> print(P2)\n CP(L=0, I=0)\n >>> print(P1.id, P2.id) # instance's ids\n 0 1\n >>> # look for object by instance's ids\n >>> print(CP.get_instance(0), CP.get_instance(1))\n CP(L=1, I=5) CP(L=0, I=0)\n >>> P2.L += 1; P2.I += 10 # assignment, fields are mutable\n >>> print(P2)\n CP(L=1, I=10)\n >>> # Accumulate using accumulate()\n >>> P1.accumulate(L=1, I=2)\n >>> print(P1)\n CP(L=2, I=7)\n >>> # ... or accum_from()\n >>> P2.accum_from(P1)\n >>> print(P2)\n CP(L=3, I=17)\n >>> # field/param types are not constrained, so be careful!\n >>> P2.L = 'something'\n >>> print(P2)\n CP(L='something', I=10)\n \"\"\"\n\n def __init__(self, **kwargs):\n pass\n\n def accum_from(self, other, excluded=()):\n \"\"\"Accumulate params from another structure.\"\"\"\n\n # accumulate base params\n for param in self.numeric_params:\n if (param not in excluded) and (param in other.numeric_params):\n p = getattr(self,param)\n _p = getattr(other,param)\n setattr(self, param, p+_p)\n\n # accumulate layers 1 and above\n for layer_num in self.dict_params:\n if (layer_num in other.dict_params):\n\n layer = getattr(self,layer_num) # self layer params\n _layer = getattr(other,layer_num) # other layer params\n\n if len(layer) == len(_layer): # both layers have the same params\n for i, ((param_name,dert), (_param_name,_dert)) in enumerate(zip(layer.items(), _layer.items())):\n # accumulate _dert into dert\n if not isinstance(dert, Cdert) and isinstance(_dert, Cdert): # if base param < ave_comp?\n layer[param_name] = _dert\n elif isinstance(dert, Cdert) and isinstance(_dert, Cdert):\n dert.p += _dert.p\n dert.d += _dert.d\n dert.m += _dert.m\n elif len(_layer)>0: # _layer is not empty but layer is empty\n setattr(self,layer_num,_layer.copy())\n\n\nclass Cdert(Number): # Ppd and Ppdm might not relevant now, so remove it\n __slots__ = ('i','p','d','m')\n\n def __init__(self, i=0, p=0, d=0, m=0):\n self.i, self.p, self.d, self.m = i, d, m, p\n\n def __add__(self, other):\n return Cdert(self.i, self.p + other.p, self.d + other.d, self.m + other.m)\n\n def __repr__(self): # representation of object\n if isinstance(self.i, Cdert) or isinstance(self.p, Cdert) or isinstance(self.d, Cdert) or isinstance(self.m, Cdert):\n return \"Cdert(i=Cdert, p=Cdert, d=Cdert, m=Cdert)\"\n else:\n return \"Cdert(i={}, p={}, d={}, m={})\".format(self.i, self.p, self.d, self.m, self.p)\n\n\ndef comp_param(param, _param, param_name, ave):\n\n if isinstance(param,list): # vector\n sin, cos = param[0], param[1]\n _sin, _cos = _param[0], _param[1]\n # difference of dy and dx\n sin_da = (cos * _sin) - (sin * _cos) # sin(α - β) = sin α cos β - cos α sin β\n cos_da= (cos * _cos) + (sin * _sin) # cos(α - β) = cos α cos β + sin α sin β\n da = np.arctan2(sin_da, cos_da)\n ma = ave - abs(da) # indirect match\n dert = Cdert(i=param, p=param+_param, d=da, m=ma) # d=None? p=param+_param will sum lists?\n else: # numeric\n d = param - _param # difference\n if param_name == 'I':\n m = ave - abs(d) # indirect match\n else:\n m = min(param,_param) - abs(d)/2 - ave # direct match\n dert = Cdert(i=param, p=param+_param, d=d,m=m)\n\n return dert\n\n\nif __name__ == \"__main__\": # for tests\n\n\n # ---- root layer --------------------------------------------------------\n # using blob as example\n class CBlob(ClusterStructure):\n I = int\n Dy = int\n Dx = int\n G = int\n M = int\n Day = int\n Dax = int\n\n # blob derivatives\n class CderBlob(ClusterStructure):\n mB = int\n dB = int\n blob = object\n _blob = object\n\n class CBblob(CBlob, CderBlob):\n pass\n\n # ---- example -----------------------------------------------------------\n\n # root layer\n blob1 = CBlob(I=5, Dy=5, Dx=7, G=5, M=6, Day=4 + 5j, Dax=8 + 9j)\n derBlob1 = CderBlob(mB=5, dB=5)\n\n # example of value inheritance, bblob now will having parameter values from blob1 and derBlob1\n # In this example, Dy and Dx are excluded from the inheritance\n bblob = CBblob(inherit=[blob1, derBlob1], excluded=['Dy','Dx'])\n\n print(bblob)"
] | [
[
"numpy.arctan2"
]
] |
juvenilehex/ml2 | [
"57fa64660a87b2e432872c06414d1a86846ce380"
] | [
"hunkim/ml_lab_03_02.py"
] | [
"# 참고자료\n# 모두를 위한 머신러닝/딥러닝 강의\n# 홍콩과기대 김성훈\n# http://hunkim.github.io/ml\n\nimport tensorflow as tf\nimport matplotlib.pyplot as plt\n\nx_data = [1., 2., 3.]\ny_data = [1., 2., 3.]\n\nW = tf.Variable(tf.random_uniform([1], -10.0, 10.0))\n\nX = tf.placeholder(tf.float32)\nY = tf.placeholder(tf.float32)\n\n\nhypothesis = W * X\n\ncost = tf.reduce_mean(tf.square(hypothesis - Y))\n\n# decent = W - tf.mul(0.1, tf.reduce_mean(tf.mul((tf.mul(W, X) - Y), X)))\ndecent = W - tf.multiply(0.1, tf.reduce_mean( ((W * X) - Y) * X) )\nupdate = W.assign(decent)\n\ninit = tf.global_variables_initializer()\n\nsess = tf.Session()\nsess.run(init)\n\narrStep = []\narrCost = []\narrWeight = []\n\nfor step in range(20):\n sess.run(update, feed_dict={X: x_data, Y: y_data})\n\n arrStep.append(step)\n arrCost.append(sess.run(cost, feed_dict={X: x_data, Y: y_data}))\n arrWeight.append(sess.run(W))\n\n print(step, arrCost[step], arrWeight[step])\n\nprint('10', sess.run(hypothesis, feed_dict={X: 10}))\nprint('100', sess.run(hypothesis, feed_dict={X: 100}))\n\n# print\nplt.plot(arrStep, arrCost)\nplt.xlabel('Step')\nplt.ylabel('Cost')\nplt.show()\n"
] | [
[
"tensorflow.placeholder",
"tensorflow.global_variables_initializer",
"tensorflow.reduce_mean",
"tensorflow.random_uniform",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"tensorflow.square",
"tensorflow.Session",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.xlabel"
]
] |
fusion-flap/flap_apdcam | [
"fce208414044fb288328090ba697e8e2482e1c75"
] | [
"apdcam_control/apdcam10g_channel_map.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sun Feb 27 12:51:00 2022\n\n@author: Zoletnik\n\"\"\"\nimport numpy as np\n\ndef apdcam10g_channel_map(camera_type=None,camera_version=1):\n \"\"\"\n Returns a 2D matrix with the ADC channel numbers as one looks onto the detector.\n\n Parameters\n ----------\n camera_type : string\n The camera type. Possible values:\n 4x32: 4 columns, 32 rows\n 8x8: 8x8 pixels\n 4x16: 4 columns, 16 rows\n 8x16: 8 columns, 16 rows (4 S8550 detectors horizontolly in one column)\n 8x16A: 8 columns, 16 rows (4 S8550 detectors verticallally tiled)\n FC: 64 channel fibre coupled (returns 1x64 array)\n camera_version : int, optional\n The detector panel and amplifier version. The default is 1.\n 0: 2014 version\n 1: 2016 version\n 2: Hybrid (2016 detector with 2014 amplifiers) \n\n Raises:\n ValueError: Unkniwn camera type of version\n Returns\n -------\n channel_map: Numpy array of ints\n The ADC channel numbers as one looks onto the detector from the camera front.\n channel_map[0,0] is upper left corner\n channel_map[nr,nc] is lower right corner if nr is number of rows, nc is number of columns\n\n \"\"\"\n \n if (camera_type == \"4x32\"):\n channel_map = np.ndarray((32,4),int)\n if (camera_version == 0):\n chmap = np.array([[ 20, 90, 75, 76],\n [ 18, 92, 1, 2],\n [ 70, 69, 29, 31],\n [ 16, 15, 87, 85],\n [ 19, 17, 4, 3],\n [ 89, 91, 74, 73],\n [ 13, 14, 30, 88],\n [ 71, 72, 32, 86],\n [ 54,128,104,103],\n [ 56,126, 46, 45],\n [ 41, 42,123,121],\n [ 99,100, 49, 51],\n [ 53, 55, 47, 48],\n [127,125,101,102],\n [ 98, 97,124, 50],\n [ 44, 43,122, 52], \n [116, 58,107,108],\n [114, 60, 33, 34],\n [ 38, 37, 61, 63],\n [112,111,119,117],\n [115,113, 36, 35],\n [ 57, 59,106,105],\n [109,110, 62,120],\n [ 39, 40, 64,118],\n [ 22, 96, 8, 7],\n [ 24, 94, 78, 77], \n [ 9, 10, 27, 25], \n [ 67, 68, 81, 83],\n [ 21, 23, 79, 80],\n [ 95, 93, 5, 6],\n [ 66, 65, 28, 82],\n [ 12, 11, 26, 84]\n ])\n elif (camera_version == 1):\n chmap = np.array([[ 59, 38,125,100],\n [115,110, 53, 44],\n\t\t\t\t \t\t\t [ 60, 37,126, 99],\n\t\t\t\t\t\t\t [116,109, 54, 43],\n\t\t\t\t\t\t\t [ 40, 57, 98,127],\n\t\t\t\t\t\t\t [112,113, 42, 55],\n\t\t\t\t\t\t\t [ 39, 58, 97,128],\n\t\t\t\t\t\t\t [111,114, 41, 56],\n\t\t\t\t\t\t\t [ 24, 9, 18, 15],\n\t\t\t\t\t\t\t [ 96, 65, 90, 71], \n\t\t\t\t\t\t\t [ 23, 10, 17, 16],\n\t\t\t\t\t\t\t [ 95, 66, 89, 72],\n\t\t\t\t\t\t\t [ 11, 22, 13, 20],\n\t\t\t\t\t\t\t [ 67, 94, 69, 92],\n\t\t\t\t\t\t\t [ 12, 21, 14, 19],\n\t\t\t\t\t\t\t [ 68, 93, 70, 91],\n\t\t\t\t\t\t\t [ 27, 6, 29, 4],\n\t\t\t\t\t\t\t [ 83, 78, 85, 76],\n\t\t\t\t\t\t\t [ 28, 5, 30, 3],\n\t\t\t\t\t\t\t [ 84, 77, 86, 75],\n\t\t\t\t\t\t\t [ 8, 25, 2, 31],\n\t\t\t\t\t\t\t [ 80, 81, 74, 87],\n\t\t\t\t\t\t\t [ 7, 26, 1, 32],\n\t\t\t\t\t\t\t [ 79, 82, 73, 88],\n\t\t\t\t\t\t\t [120,105, 50, 47],\n\t\t\t\t\t\t\t [ 64, 33,122,103],\n\t\t\t\t\t\t\t [119,106, 49, 48],\n\t\t\t\t\t\t\t [ 63, 34,121,104],\n\t\t\t\t\t\t\t [107,118, 45, 52],\n\t\t\t\t\t\t\t [ 35, 62,101,124],\n\t\t\t\t\t\t\t [108,117, 46, 51],\n\t\t\t\t\t\t\t [ 36, 61,102,123]\n\t\t\t\t\t\t ])\n else:\n raise ValueError(\"Version {:d} is not possible for camera type '{:s}'.\".format(camera_type))\n return np.transpose(chmap)\n\n elif (camera_type == \"8x8\"):\n channel_map = np.ndarray((8,8),int)\n if (camera_version == 0):\n chmap = np.array([[33, 9,24,22,60,58,39,16],\n [10,34,23,21,59,15,57,40],\n [11,63,36,61,19,17,13,37],\n [35,12,64,62,20,18,38,14],\n [46, 6,50,52,30,32,44, 3],\n [ 5,45,49,51,29, 4,31,43],\n [ 8,25,47,27,53,55, 2,42],\n [48, 7,26,28,54,56,41, 1]\n ])\n elif(camera_version == 1):\n chmap = np.array([[33, 9,63,64,58,57,39,16],\n [10,34,23,24,18,15,17,40],\n [11,62,36,61,59,60,13,37],\n [35,12,22,21,19,20,38,14],\n [46, 6,52,51,53,54,44, 3],\n [ 5,45,28,27,29, 4,30,43],\n [ 8,49,47,50,56,55, 2,42],\n [48, 7,25,26,32,31,41, 1]\n ])\n elif(camera_version == 2):\n chmap = np.array([[42,41,56,54,17,19, 2, 3],\n [43,44,55,53,18, 1,20, 4],\n [39,60,38,58,29,31,14,13],\n [40,37,59,57,30,32,15,16],\n [ 8, 7,24,22,49,51,48,45],\n [ 5, 6,23,21,50,47,52,46],\n [12,28, 9,26,61,63,36,35],\n [11,10,27,25,62,64,33,34]\n ])\n else:\n raise ValueError(\"Version {:d} is not possible for camera type '{:s}'.\".format(camera_type))\n return np.transpose(chmap)\n elif (camera_type == \"8x16\"): \n channel_map = np.ndarray((16,8),int)\n if (camera_version == 0):\n chmap = np.array([[ 14, 70, 18, 20, 30, 32, 76, 3],\n [ 69, 13, 17, 19, 29, 4, 31, 75],\n [ 72, 89, 15, 91, 85, 87, 2, 74],\n [ 16, 71, 90, 92, 86, 88, 73, 1],\n [ 97, 41, 56, 54,124,122,103, 48],\n [ 42, 98, 55, 53,123, 47,121,104],\n [ 43,127,100,125, 51, 49, 45,101],\n [ 99, 44,128,126, 52, 50,102, 46],\n [110, 38,114,116, 62, 64,108, 35],\n [ 37,109,113,115, 61, 36, 63,107],\n [ 40, 57,111, 59,117,119, 34,106],\n [112, 39, 58, 60,118,120,105, 33],\n [ 65, 9, 24, 22, 28, 26, 7, 80],\n [ 10, 66, 23, 21, 27, 79, 25, 8],\n [ 11, 95, 68, 93, 83, 81, 77, 5],\n [ 67, 12, 96, 94, 84, 82, 6, 78]\n ])\n elif (camera_version == 1):\n chmap = np.array([[110, 38,116,115, 53, 54, 44, 99],\n [ 37,109, 60, 59,125,100,126, 43],\n [ 40,113,111,114, 56, 55, 98, 42],\n [112, 39, 57, 58,128,127, 41, 97],\n [ 65, 9, 95, 96, 90, 89, 71, 16],\n [ 10, 66, 23, 24, 18, 15, 17, 72],\n [ 11, 94, 68, 93, 91, 92, 13, 69],\n [ 67, 12, 22, 21, 19, 20, 70, 14],\n [ 78, 6, 84, 83, 85, 86, 76, 3],\n [ 5, 77, 28, 27, 29, 4, 30, 75],\n [ 8, 81, 79, 82, 88, 87, 2, 74],\n [ 80, 7, 25, 26, 32, 31, 73, 1],\n [ 33,105, 63, 64,122,121,103, 48],\n [106, 34,119,120, 50, 47, 49,104],\n [107, 62, 36, 61,123,124, 45,101],\n [ 35,108,118,117, 51, 52,102, 46]\n ])\n else:\n raise ValueError(\"Version {:d} is not possible for camera type '{:s}'.\".format(camera_type))\n return np.transpose(chmap)\n elif (camera_type == \"4x16\"): \n channel_map = np.ndarray((16,4),int)\n if (camera_version == 0):\n chmap = np.array([[22,64,40,39],\n [24,62,14,13],\n [ 9,10,59,57],\n [35,36,17,19],\n [21,23,15,16],\n [63,61,37,38],\n [34,33,60,18],\n [12,11,58,20],\n [52,26,43,44],\n [50,28, 1, 2],\n [ 6, 5,29,31],\n [48,47,55,53],\n [51,49, 4, 3],\n [25,27,42,41],\n [45,46,30,56],\n [ 7, 8,32,54]\n ])\n elif (camera_version == 1):\n chmap = np.array([[ 24, 9, 18, 15],\n\t\t\t\t\t\t\t [ 64, 33, 58, 39], \n\t\t\t\t\t\t\t [ 23, 10, 17, 16],\n\t\t\t\t\t\t\t [ 63, 34, 57, 40],\n\t\t\t\t\t\t\t [ 11, 22, 13, 20],\n\t\t\t\t\t\t\t [ 35, 62, 37, 60],\n\t\t\t\t\t\t\t [ 12, 21, 14, 19],\n\t\t\t\t\t\t\t [ 36, 61, 38, 59],\n\t\t\t\t\t\t\t [ 27, 6, 29, 4],\n\t\t\t\t\t\t\t [ 51, 46, 53, 44],\n\t\t\t\t\t\t\t [ 28, 5, 30, 3],\n\t\t\t\t\t\t\t [ 52, 45, 54, 43],\n\t\t\t\t\t\t\t [ 8, 25, 2, 31],\n\t\t\t\t\t\t\t [ 48, 49, 42, 55],\n\t\t\t\t\t\t\t [ 7, 26, 1, 32],\n\t\t\t\t\t\t\t [ 47, 50, 41, 56]\t\t\t\t\t\t\t \n\t\t\t\t\t\t ])\n elif (camera_version == 2):\n chmap = np.array([[61,47,26, 6],\n [62,48,25, 5],\n [63,45,28, 8],\n [64,46,27, 7],\n [36,51,12,24],\n [35,52,11,23],\n [34,49,10,22],\n [33,50, 9,21],\n [29, 1,58,41],\n [30, 2,57,42],\n [31, 3,60,43],\n [32, 4,59,44],\n [14,19,38,56],\n [13,20,37,55],\n [16,17,40,54],\n [15,18,39,53]\n ])\n else:\n raise ValueError(\"Version {:d} is not possible for camera type '{:s}'.\".format(camera_type))\n return np.transpose(chmap)\n elif (camera_type == \"8x16A\"):\n channel_map = np.ndarray((16,8),int)\n if (camera_version == 1):\n chmap = np.array([[ 91, 19, 14, 70, 76, 4, 29, 85],\n [ 20, 92, 69, 16, 3, 75, 86, 31],\n [ 17, 89, 13, 72, 2, 74, 30, 87],\n [ 18, 90, 15, 71, 1, 73, 32, 88],\n [ 56,128, 41, 97,103, 47,122, 50],\n [ 55,126, 42, 98,104, 45,121, 49],\n [127, 54, 43, 99, 48,101,124, 52],\n [ 53,125,100, 44,102, 46, 51,123],\n [ 59,115,110, 38,108, 36, 61,117],\n [116, 60, 37,112, 35,107,118, 63],\n [113, 57,109, 40, 34,106, 62,119],\n [114, 58,111, 39, 33,105, 64,120],\n [ 24, 96, 9, 65, 7, 79, 26, 82],\n [ 23, 94, 10, 66, 8, 77, 25, 81],\n [ 95, 22, 11, 67, 80, 5, 28, 84],\n [ 21, 93, 68, 12, 6, 78, 83, 27]\n ])\n else:\n raise ValueError(\"Version {:d} is not possible for camera type '{:s}'.\".format(camera_version,camera_type))\n return np.transpose(chmap)\n elif (camera_type == \"FC\"):\n np.arange(64,dtype=int) \n else:\n raise ValueError('Unknown camera type:\"{:s}\"'.format(camera_type))"
] | [
[
"numpy.ndarray",
"numpy.arange",
"numpy.transpose",
"numpy.array"
]
] |
RulerOf/keras-yolo3 | [
"8d091cf42b2f126626ad8610adf31293225b7daa"
] | [
"scripts/evaluate.py"
] | [
"\"\"\"\nEvaluation of predictions againsts given dataset (in TXT format the same as training).\nWe expect that the predictions are in single folder and image names in dataset are the same\n\n python evaluate.py \\\n --path_dataset ../model_data/VOC_2007_train.txt \\\n --path_results ../results \\\n --confidence 0.5 \\\n --iou 0.5 \\\n --visual\n\nIt generates\n* statistic per image (mean over all classes)\n* statistic per class (mean over all images)\n\nSee:\n- https://github.com/rafaelpadilla/Object-Detection-Metrics\n\"\"\"\n\nimport os\nimport sys\nimport argparse\nimport logging\nfrom functools import partial\nfrom pathos.multiprocessing import ProcessPool\n\nimport tqdm\nimport pandas as pd\n\nsys.path += [os.path.abspath('.'), os.path.abspath('..')]\nfrom keras_yolo3.utils import check_params_path, nb_workers, image_open, update_path\nfrom keras_yolo3.model import compute_detect_metrics\nfrom keras_yolo3.visual import draw_bounding_box\n\nCSV_NAME_RESULTS_IMAGES = 'detection-results_conf=%.2f_iou=%.2f_stat-images.csv'\nCSV_NAME_RESULTS_CLASSES = 'detection-results_conf=%.2f_iou=%.2f_stat-classes.csv'\nANNOT_COLUMNS = ('xmin', 'ymin', 'xmax', 'ymax', 'class')\n# DETECT_COLUMNS = ('xmin', 'ymin', 'xmax', 'ymax', 'class', 'confidence')\nTEMP_IMAGE_NAME = '%s_visual.jpg'\n\n\ndef parse_params():\n # class YOLO defines the default value, so suppress any default HERE\n parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)\n parser.add_argument('-d', '--path_dataset', type=str, required=True,\n help='path to the dataset, with single instance per line')\n parser.add_argument('-r', '--path_results', type=str, required=True,\n help='path to the predictions')\n parser.add_argument('-c', '--confidence', type=float, required=False, default=0.5,\n help='detection confidence score')\n parser.add_argument('--iou', type=float, required=False, default=0.5,\n help='intersection over union')\n parser.add_argument('--nb_jobs', type=float, help='number of parallel processes',\n default=0.9, required=False)\n parser.add_argument('--visual', default=False, action='store_true',\n help='visualize annot & predict')\n arg_params = vars(parser.parse_args())\n arg_params = check_params_path(arg_params)\n logging.debug('PARAMETERS: \\n %s', repr(arg_params))\n return arg_params\n\n\ndef draw_export_bboxes(img_path, path_out, bboxes_anot, bboxes_pred):\n img_name, _ = os.path.splitext(os.path.basename(img_path))\n image = image_open(img_path)\n\n for bb in bboxes_anot:\n image = draw_bounding_box(image, bb[4], bb[:4], swap_xy=True,\n color=(0, 255, 0), thickness=2)\n for bb in bboxes_pred:\n image = draw_bounding_box(image, bb[4], bb[:4], swap_xy=True,\n color=(255, 0, 0), thickness=2)\n\n name_visu = TEMP_IMAGE_NAME % img_name\n path_visu = os.path.join(update_path(path_out), name_visu)\n image.save(path_visu)\n return path_visu\n\n\ndef eval_image(line, path_results, thr_confidence=0.5, thr_iou=0.5, path_out=None):\n line_elems = line.strip().split()\n img_path = line_elems[0]\n img_name, _ = os.path.splitext(os.path.basename(img_path))\n\n path_pred = os.path.join(path_results, '%s.csv' % img_name)\n if not os.path.isfile(path_pred):\n return None\n\n boxes = [list(map(int, el.split(','))) for el in line_elems[1:]]\n df_annot = pd.DataFrame(boxes, columns=list(ANNOT_COLUMNS))\n if df_annot.empty:\n df_annot = pd.DataFrame(columns=ANNOT_COLUMNS)\n df_preds = pd.read_csv(path_pred, index_col=None)\n if df_preds.empty:\n df_preds = pd.DataFrame(columns=ANNOT_COLUMNS)\n\n # old version uses `score` instead `confidence`\n if 'confidence' not in df_preds.columns and 'score' in df_preds.columns:\n cols = df_preds.columns.tolist()\n idx = cols.index('score')\n df_preds.columns = cols[:idx] + ['confidence'] + cols[idx + 1:]\n # if confidence/score is defined, filter detections\n if 'confidence' in df_preds.columns:\n df_preds = df_preds[df_preds['confidence'] >= thr_confidence]\n # if class detection is not defined, assume everything as 0\n if 'class' not in df_preds.columns:\n df_preds['class'] = 0\n # in case one of DF does not have required columns skip it...\n all_cols_in_annot = all([c in df_annot.columns for c in ANNOT_COLUMNS])\n all_cols_in_pred = all([c in df_preds.columns for c in ANNOT_COLUMNS])\n if not (all_cols_in_annot and all_cols_in_pred):\n return None\n\n stats = compute_detect_metrics(df_annot[list(ANNOT_COLUMNS)], df_preds[list(ANNOT_COLUMNS)],\n iou_thresh=thr_iou)\n\n if path_out and os.path.isdir(path_out):\n draw_export_bboxes(img_path, path_out,\n df_annot[list(ANNOT_COLUMNS)].values,\n df_preds[list(ANNOT_COLUMNS)].values)\n\n # stats['name'] = img_name\n return stats\n\n\ndef _main(path_dataset, path_results, confidence, iou, visual=False, nb_jobs=0.9):\n with open(path_dataset, 'r') as fp:\n dataset = fp.readlines()\n\n if not dataset:\n logging.warning('Dataset is empty - %s', path_dataset)\n return\n\n nb_jobs = nb_workers(nb_jobs)\n pool = ProcessPool(nb_jobs) if nb_jobs > 1 else None\n _wrap_eval = partial(eval_image, path_results=path_results,\n thr_confidence=confidence, thr_iou=iou,\n path_out=path_results if visual else None)\n # multiprocessing loading of batch data\n map_process = pool.imap if pool else map\n\n results_image, results_class = [], []\n for stat in tqdm.tqdm(map_process(_wrap_eval, dataset), desc='Evaluation'):\n if not stat:\n continue\n results_image.append(dict(pd.DataFrame(stat).mean()))\n results_class += stat\n\n df_results_image = pd.DataFrame(results_image)\n logging.info(df_results_image.describe())\n path_csv = os.path.join(path_results, CSV_NAME_RESULTS_IMAGES % (confidence, iou))\n logging.debug('exporting csv: %s', path_csv)\n df_results_image.to_csv(path_csv)\n\n df_results_class = pd.DataFrame()\n for gr, df_gr in pd.DataFrame(results_class).groupby('class'):\n df_results_class = df_results_class.append(df_gr.mean(), ignore_index=True)\n logging.info(df_results_class)\n path_csv = os.path.join(path_results, CSV_NAME_RESULTS_CLASSES % (confidence, iou))\n logging.debug('exporting csv: %s', path_csv)\n df_results_class.to_csv(path_csv)\n\n\nif __name__ == '__main__':\n logging.basicConfig(level=logging.INFO)\n pd.set_option(\"display.max_columns\", 25)\n arg_params = parse_params()\n _main(**arg_params)\n logging.info('Done')\n"
] | [
[
"pandas.read_csv",
"pandas.DataFrame",
"pandas.set_option"
]
] |
b2-hive/CONTRE | [
"9176861400fcc5887d8a8944ee2c636ba09aa239"
] | [
"contre/training.py"
] | [
"import root_pandas\nimport basf2_mva\nimport b2luigi\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\n\n\ndef split_sample(\n ntuple_file,\n train_size,\n test_size,\n random_seed=42):\n \"\"\"Split rootfile and return dataframes. Select 0th candidate.\"\"\"\n df = root_pandas.read_root(ntuple_file)\n try:\n train, test = train_test_split(\n df,\n test_size=test_size,\n train_size=train_size,\n random_state=random_seed)\n except ValueError:\n print(\n \"The dataframe was too small, the test and train sample are empty\")\n empty = {col: [] for col in df.columns}\n test = pd.DataFrame(empty)\n train = pd.DataFrame(empty)\n if train.get(\"__candidate__\") is not None:\n train = train[train[\"__candidate__\"] == 0]\n return train, test\n\n\nclass SplitSample(b2luigi.Task):\n \"\"\"Split a ntuple file to a training and test sample of given size.\n\n Shuffle events and create a random selected train and test sample.\n The function sklearn.utils.resample is used.\n Store samples as rootfiles (used by fastBDT).\n\n Parameters:\n ntuple_file (str): Path to the file\n train_size (float): between 0 and 1, size of train sample\n test_size (float): size of test sample\n \"\"\"\n ntuple_file = b2luigi.Parameter(hashed=True)\n tree_name = b2luigi.Parameter()\n train_size = b2luigi.FloatParameter()\n test_size = b2luigi.FloatParameter()\n queue = \"sx\"\n\n def output(self):\n yield self.add_to_output('train.root')\n yield self.add_to_output('test.root')\n\n def run(self):\n train, test = split_sample(\n ntuple_file=self.ntuple_file,\n train_size=self.train_size,\n test_size=self.test_size)\n\n # Store as Rootfile\n root_pandas.to_root(\n train, self.get_output_file_name('train.root'), key=self.tree_name)\n root_pandas.to_root(\n test, self.get_output_file_name('test.root'), key=self.tree_name)\n\n\nclass Training(b2luigi.Task):\n \"\"\"Train a fastBDT on train samples of the given off-resonance files and\n save bdt_weightfile to `bdt.xml`.\n\n Parameters:\n off_res_files (list): list of off-resonance files to be used for\n training,\n tree_name (str): name of the tree in the root file,\n training_variables (list): variables used for training,\n If you have multiple candidates in your selection, be aware that\n only the 0th candidate is used for training.\n This does not have any effect, if you only use event-based\n variables for training.\n training_parameters (dict): train- and test size,\n the following BDT hyper-parameters (optional): \"nTrees\",\n \"shrinkage\" and \"nLevels\".\n \"\"\"\n off_res_files = b2luigi.ListParameter(hashed=True)\n tree_name = b2luigi.ListParameter()\n training_variables = b2luigi.ListParameter(hashed=True)\n training_parameters = b2luigi.DictParameter(hashed=True)\n queue = \"sx\"\n\n def requires(self):\n train_size = self.training_parameters[\"train_size\"]\n test_size = self.training_parameters[\"test_size\"]\n\n for ntuple_file in self.off_res_files:\n yield self.clone(\n SplitSample,\n ntuple_file=ntuple_file,\n train_size=train_size,\n test_size=test_size)\n\n def output(self):\n yield self.add_to_output('bdt.xml')\n\n def run(self):\n bdt = self.get_output_file_name('bdt.xml')\n train_samples = self.get_input_file_names('train.root')\n\n # bdt options\n general_options = basf2_mva.GeneralOptions()\n general_options.m_datafiles = basf2_mva.vector(*train_samples)\n general_options.m_identifier = bdt\n general_options.m_treename = self.tree_name\n general_options.m_variables = basf2_mva.vector(\n *self.training_variables)\n general_options.m_target_variable = \"EventType\"\n\n fastbdt_options = basf2_mva.FastBDTOptions()\n training_parameters = self.training_parameters\n if training_parameters.get(\"nTrees\") is not None:\n fastbdt_options.m_nTrees = training_parameters[\"nTrees\"]\n if training_parameters.get(\"shrinkage\") is not None:\n fastbdt_options.m_shrinkage = training_parameters[\"shrinkage\"]\n if training_parameters.get(\"nLevels\") is not None:\n fastbdt_options.m_nLevels = training_parameters[\"nLevels\"]\n if training_parameters.get(\"nCuts\") is not None:\n fastbdt_options.m_nCuts = training_parameters[\"nCuts\"]\n\n # teacher\n basf2_mva.teacher(general_options, fastbdt_options)\n"
] | [
[
"pandas.DataFrame",
"sklearn.model_selection.train_test_split"
]
] |
masonng-astro/nicerpy_xrayanalysis | [
"c21c7c9bc5570c63c986197fb363ae80691515d5"
] | [
"Lv3_presto_candidates.py"
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Fri Jul 5 1:28pm 2019\n\nScript to automate getting pulsation candidates of a certain frequency range,\nand reporting other germane information?\n\n\"\"\"\nfrom __future__ import division, print_function\nimport numpy as np\nfrom scipy import stats, signal\nfrom tqdm import tqdm\nimport matplotlib.pyplot as plt\nfrom astropy.io import fits\nimport glob\nimport Lv0_dirs\n\nLv0_dirs.global_par()\n\ndef get_candidates(obsid,name_par_list,zmax,f1,f2):\n \"\"\"\n Getting pulsation candidates within some frequency range. If I want the full\n frequency range, just do f1 = 0, f2 = some large number.\n\n obsid - Observation ID of the object of interest (10-digit str)\n name_par_list - list of parameters specifying parameters like GTI number and/or energy range\n zmax - maximum acceleration\n f1 - lower limit of frequency range\n f2 - upper limit of frequency range\n\n name_par_list should be [GTI_true,E_true,GTIno,segment_length,PI1,PI2]\n \"\"\"\n if type(obsid) != str:\n raise TypeError(\"ObsID should be a string!\")\n if type(name_par_list) != list and type(name_par_list) != np.ndarray:\n raise TypeError(\"name_par_list should either be a list or an array!\")\n if len(name_par_list) != 6:\n raise ValueError(\"There seems to be fewer or more values in the list/array than there should be! You should have [GTI_true, E_true, GTIno, segment length, PI1, PI2]\")\n\n header1 = \" Summed Coherent Num Period Frequency FFT 'r' Freq Deriv FFT 'z' Accel \"\n header2 = \" Power / Raw FFT 'r' Pred 'r' FFT 'z' Pred 'z' Phase Centroid Purity \"\n\n obsid_file = Lv0_dirs.NICERSOFT_DATADIR + obsid + '_pipe/ni' + obsid + '_nicersoft_bary.evt'\n header_card = fits.open(obsid_file)[0].header\n date_obs = str(header_card['DATE-OBS'])\n date_end = str(header_card['DATE-END'])\n tstart = str(header_card['TSTART'])\n tstop = str(header_card['TSTOP'])\n\n if name_par_list[0] == True and name_par_list[1] == False: #if we're looking at just time segments!\n working_dir = Lv0_dirs.NICERSOFT_DATADIR + obsid + '_pipe/accelsearch_' + str(name_par_list[3]) + 's/'\n ACCEL_files = sorted(glob.glob(working_dir+'*_' + str(name_par_list[3]) + 's_ACCEL_' + str(zmax)))\n cands_txt = open(working_dir+'candidates_'+str(name_par_list[3])+'s_raw.txt','w')\n cands_txt.write('ObsID Start-date/time-of-obs End-date/time-of-obs MET_start MET_end seg_no MET_centroid Cand_No Sigma Frequency Freq_Deriv z Acceleration' + '\\n')\n \"\"\"\n JULY 8: Got to edit the below as appropriate! Mainly got to think about how to replace seg_no!\n ACTUALLY, BREAK THIS UP INTO 3 SEPARATE FUNCTIONS! Integrate into Lv3_presto_main as well...\n elif name_par_list[0] == False and name_par_list[1] == True: #if we're looking at just energy segments!\n working_dir = Lv0_dirs.NICERSOFT_DATADIR + obsid + '_pipe/'\n ACCEL_files = sorted(glob.glob(working_dir+'*E'+str(name_par_list[4]) + '-' + str(name_par_list[5])))\n cands_txt = open(working_dir+'candidates_raw.txt','w')\n cands_txt.write('ObsID Start-date/time-of-obs End-date/time-of-obs MET_start MET_end seg_no MET_centroid Cand_No Sigma Frequency Freq_Deriv z Acceleration' + '\\n')\n else: #if we're looking at BOTH time AND energy segments!\n working_dir = Lv0_dirs.NICERSOFT_DATADIR + obsid + '_pipe/accelsearch_' + str(name_par_list[3]) + 's/'\n ACCEL_files = sorted(glob.glob(working_dir+'*_' + str(name_par_list[3]) + 's_ACCEL_' + str(zmax)))\n cands_txt = open(working_dir+'candidates_raw.txt','w')\n cands_txt.write('ObsID Start-date/time-of-obs End-date/time-of-obs MET_start MET_end seg_no MET_centroid Cand_No Sigma Frequency Freq_Deriv z Acceleration' + '\\n')\n \"\"\"\n for i in range(len(ACCEL_files)):\n accel_textfile = np.array(open(ACCEL_files[i],'r').read().split('\\n')) #read the data from the ACCEL_$zmax files\n index_header1 = np.where(accel_textfile==header1)[0][0] #index for \"Summed, Coherent, Num, Period etc\n index_header2 = np.where(accel_textfile==header2)[0][0] #index for \"Power / Raw FFT 'r' etc\n no_cands = index_header2 - index_header1 - 5 #to obtain number of candidates\n\n segment_no = '0004'\n MET_centroid = '141080121.942' #test\n candidates = np.genfromtxt(ACCEL_files[i],dtype='str',skip_header=3,usecols=(0,1,6,8,9,10),unpack=True,max_rows=no_cands)\n if len(candidates) == candidates.size: #meaning if there's ONE pulsation candidate in the *ACCEL_$zmax file\n if (np.float(candidates[2][:-3]) > f1) and (np.float(candidates[2][:-3]) < f2):\n cands_txt.write(obsid + ' ' + date_obs + ' ' + date_end + ' ' + tstart + ' ' + tstop + ' ' + segment_no + ' ' + MET_centroid + ' ' + candidates[0].zfill(4) + ' ' + candidates[1] + ' ' + candidates[2] + ' ' + candidates[3] + ' ' + candidates[4] + ' ' + candidates[5] + '\\n')\n else: #if there are multiple pulsation candidates in the *ACCEL_$zmax file\n for j in range(candidates.shape[1]): #for EACH pulsation candidate\n if (np.float(candidates[2][j][:-3]) > f1) and (np.float(candidates[2][j][:-3]) < f2):\n cands_txt.write(obsid + ' ' + date_obs + ' ' + date_end + ' ' + tstart + ' ' + tstop + ' ' + segment_no + ' ' + MET_centroid + ' ' + candidates[0][j].zfill(4) + ' ' + candidates[1][j] + ' ' + candidates[2][j] + ' ' + candidates[3][j] + ' ' + candidates[4][j] + ' ' + candidates[5][j] + '\\n')\n\nif __name__ == \"__main__\":\n get_candidates('1200250101',[True,False,0,64,0,0],100,0,100)\n"
] | [
[
"numpy.where",
"numpy.float",
"numpy.genfromtxt"
]
] |
gradientzero/dq0-sdk | [
"90856dd5ac56216971ffe33004447fd037a21660"
] | [
"dq0/sdk/examples/newsgroups/_data/generate_preprocessed_dataset.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"20Newsgroups Data Source.\n\nThis is a data source example known from the Scikit-learn API:\nhttps://scikit-learn.org/stable/datasets/index.html#the-20-newsgroups-text-dataset\n\nThe 20 newsgroups dataset comprises around 18000 newsgroups posts on 20 topics\nsplit in two subsets: one for training (or development) and the other one\nfor testing (or for performance evaluation). The split between the train and\ntest set is based upon a messages posted before and after a specific date.\n\nCopyright 2020, Gradient Zero\nAll rights reserved\n\"\"\"\n\nfrom pathlib import Path\n\nfrom dq0.sdk.data.preprocessing import preprocessing\nfrom dq0.sdk.data.utils import util\nfrom dq0.sdk.examples.newsgroups._data.dump_text_labels_to_df_csv import \\\n _dump_text_and_labels_to_csv\n\nimport pandas as pd\n\nfrom sklearn.model_selection import train_test_split\n\n\ndef _generate_preprocessed_dataset(X, y):\n\n # fillna with empty strings (exist in original)\n X.fillna(\"\", inplace=True)\n\n # Split for preprocessing\n # If the input is sparse, the output will be a scipy.sparse.csr_matrix.\n # Otherwise, output type is the same as the input type.\n X_train_df, X_test_df, y_train_se, y_test_se = \\\n train_test_split(X, y, test_size=0.1)\n\n X_train_sp_matr, X_test_sp_matr, feature_names_list = \\\n preprocessing.extract_count_features_from_text_corpus(\n X_train_df.values.tolist(),\n X_test_df.values.tolist()\n )\n\n # Set the number of features for feature extraction\n #\n # WARNING!!! when setting num_top_ranked_feats_to_keep to 20k,\n # DP fitting takes more than an hour\n #\n num_top_ranked_feats_to_keep = int(5e3) # set to 'all' to skip feat sel.\n if str(num_top_ranked_feats_to_keep).lower() != 'all':\n technique_for_feat_sel = 'chi-squared test' # 'mutual information'\n\n if str(num_top_ranked_feats_to_keep).lower() != 'all':\n X_train_sp_matr, X_test_sp_matr, feature_names_list = \\\n preprocessing.univariate_feature_selection(\n num_top_ranked_feats_to_keep,\n X_train_sp_matr,\n y_train_se,\n X_test_sp_matr,\n technique=technique_for_feat_sel,\n feature_names_list=feature_names_list\n )\n\n sparse_representation = False\n X_train_df = util.sparse_scipy_matrix_to_Pandas_df(\n X_train_sp_matr,\n sparse_representation,\n columns_names_list=feature_names_list)\n\n X_test_df = util.sparse_scipy_matrix_to_Pandas_df(\n X_test_sp_matr,\n sparse_representation,\n columns_names_list=feature_names_list)\n\n X = pd.concat([X_train_df, X_test_df], ignore_index=True)\n y = pd.concat([y_train_se, y_test_se], ignore_index=True)\n y.name = 'label'\n df = pd.concat([X, y], axis=1)\n\n print('\\nGenerated dataset for 20Newsgroups:')\n print('\\tfeature matrix shape:', X.shape)\n print('\\tclass-labels vector shape:', y.shape)\n print('\\tnum classes:', y.nunique())\n print('\\tShape of DataFrame saved in file:', df.shape)\n\n return df\n\n\nif __name__ == '__main__':\n\n # fetch raw text data\n raw_data_csv = '../dq0-sdk/dq0/sdk/examples/newsgroups/_data' \\\n '/20newsgroups_text_label_df.csv'\n\n if not Path(raw_data_csv).is_file():\n # file does not exists\n _dump_text_and_labels_to_csv(raw_data_csv)\n\n dataset = pd.read_csv(raw_data_csv)\n\n df = _generate_preprocessed_dataset(dataset.iloc[:, 0], dataset.iloc[:, 1])\n\n df.to_csv(\n '../dq0-sdk/dq0/sdk/examples/newsgroups/_data/preprocessed_dataset'\n '.csv', index=False\n )\n\n # preprocessed_dataset.csv size is 366MB, so it is not kept in the\n # repository.\n"
] | [
[
"pandas.read_csv",
"pandas.concat",
"sklearn.model_selection.train_test_split"
]
] |
village-people/flying-pig | [
"c86b589aadb02dbfd42a917a388c2b8488ecd338"
] | [
"ai_challenge/methods/dqn.py"
] | [
"\"\"\" Deep Q-Learning policy evaluation and improvement\n\"\"\"\nimport torch\nfrom torch.autograd import Variable\nimport torch.nn.functional as F\nimport torch.optim as optim\n\nfrom termcolor import colored as clr\n\n\nclass DQNPolicyImprovement(object):\n \"\"\" Deep Q-Learning training method. \"\"\"\n\n def __init__(self, policy, target_policy, cfg, ddqn=False):\n self.name = \"DQN-PI\"\n self.policy = policy\n self.target_policy = target_policy\n\n self.lr = cfg.training.lr\n self.gamma = cfg.agent.gamma\n\n self.optimizer = optim.Adam(self.policy.parameters(), lr=self.lr)\n self.optimizer.zero_grad()\n\n self.decouple_grad = False\n self.grads_decoupled = False\n self.ddqn = ddqn\n\n def accumulate_gradient(self, batch_sz, states, actions, rewards,\n next_states, mask, next_actions=None):\n \"\"\" Compute the temporal difference error.\n td_error = (r + gamma * max Q(s_,a)) - Q(s,a)\n \"\"\"\n states = Variable(states)\n actions = Variable(actions)\n rewards = Variable(rewards)\n next_states = Variable(next_states, volatile=True)\n if self.ddqn:\n next_actions = Variable(next_actions)\n\n # Compute Q(s, a)\n policy_val = self.policy(states)\n q_values = policy_val.gather(1, actions.unsqueeze(1))\n\n # Compute Q(s_, a)\n q_target_values = None\n if next_states.is_cuda:\n q_target_values = Variable(torch.zeros(batch_sz).cuda())\n else:\n q_target_values = Variable(torch.zeros(batch_sz))\n\n # Bootstrap for non-terminal states\n real_mask = Variable(mask)\n target_q_values = self.target_policy(next_states)\n\n if self.ddqn:\n policy_next_state = target_q_values.gather(\n 1, next_actions.unsqueeze(1)).squeeze()\n else:\n policy_next_state = target_q_values.max(1)[0].view(-1)\n\n q_target_values.scatter_(0, real_mask, policy_next_state)\n\n q_target_values.volatile = False # So we don't mess the huber loss\n expected_q_values = (q_target_values * self.gamma) + rewards\n\n # Compute Huber loss\n loss = F.smooth_l1_loss(q_values, expected_q_values)\n loss.data.clamp_(-1, 1)\n # print(\"Loss: {:.6f}\".format(loss.data[0]))\n # Accumulate gradients\n loss.backward()\n\n def update_model(self):\n for param in self.policy.parameters():\n param.grad.data.clamp_(-1, 1)\n if not self.grads_decoupled and self.decouple_grad:\n param.grad.data = param.grad.data.clone()\n self.grads_decoupled = True\n\n self.optimizer.step()\n self.optimizer.zero_grad()\n\n def update_target_net(self):\n \"\"\" Update the target net with the parameters in the online model.\"\"\"\n self.target_policy.load_state_dict(self.policy.state_dict())\n\n def get_model_stats(self):\n if self.grads_decoupled or not self.decouple_grad:\n param_abs_mean = 0\n grad_abs_mean = 0\n t_param_abs_mean = 0\n n_params = 0\n for p in self.policy.parameters():\n param_abs_mean += p.data.abs().sum()\n grad_abs_mean += p.grad.data.abs().sum()\n n_params += p.data.nelement()\n for t in self.target_policy.parameters():\n t_param_abs_mean += t.data.abs().sum()\n\n print(\"Wm: %.9f | Gm: %.9f | Tm: %.9f\" % (\n param_abs_mean / n_params,\n grad_abs_mean / n_params,\n t_param_abs_mean / n_params))\n\n def _debug_transitions(self, mask, reward_batch):\n if mask[0] == 0:\n r = reward_batch[0, 0]\n if r == 1.0:\n print(r)\n\n def _debug_states(self, state_batch, next_state_batch, mask):\n for i in range(24):\n for j in range(24):\n px = state_batch[0, 0, i, j]\n if px < 0.90:\n print(clr(\"%.2f \" % px, 'magenta'), end=\"\")\n else:\n print((\"%.2f \" % px), end=\"\")\n print()\n for i in range(24):\n for j in range(24):\n px = next_state_batch[0, 0, i, j]\n if px < 0.90:\n print(clr(\"%.2f \" % px, 'magenta'), end=\"\")\n else:\n print(clr(\"%.2f \" % px, 'white'), end=\"\")\n print()\n if mask[0] == 0:\n print(clr(\"Done batch ............\", 'magenta'))\n else:\n print(\".......................\")\n"
] | [
[
"torch.zeros",
"torch.autograd.Variable",
"torch.nn.functional.smooth_l1_loss"
]
] |
cnavarreteliz/Datos-COVID19 | [
"4383c6a82f5ec41d55875daf6ce2d2ed71785aa4"
] | [
"src/bulk_producto2.py"
] | [
"import pandas as pd\nimport glob\nimport re\n\ndf = []\nfor file in glob.glob(\"../output/producto2/*.csv\"):\n date = re.search(\"\\d{4}-\\d{2}-\\d{2}\", file).group(0).replace(\"-\", \"/\")\n fragment = pd.read_csv(file)\n fragment[\"Fecha\"] = date\n df.append(fragment)\n\ndf = pd.concat(df)\n\n# Reemplaza nombres de comuna, para coincidir con los publicados por SUBDERE\ndf[\"Comuna\"] = df[\"Comuna\"].replace({\"Coyhaique\": \"Coihaique\", \"OHiggins\": \"O'Higgins\"})\n\n# Lee IDs de comunas desde página web oficial de SUBDERE\ndf_dim_comunas = pd.read_excel(\"http://www.subdere.gov.cl/sites/default/files/documentos/cut_2018_v03.xls\", encoding=\"utf-8\")\n\n# Crea columna sin tildes, para hacer merge con datos publicados\ndf_dim_comunas[\"Comuna\"] = df_dim_comunas[\"Nombre Comuna\"].str.normalize(\"NFKD\").str.encode(\"ascii\", errors=\"ignore\").str.decode(\"utf-8\")\n\ndf = df.merge(df_dim_comunas, on=\"Comuna\", how=\"outer\")\n\ndf = df.drop(columns=[\"Comuna\", \"Region\", \"Codigo region\", \"Codigo comuna\"])\ndf = df.rename(columns={\n \"Nombre Región\": \"Region\",\n \"Nombre Provincia\": \"Provincia\", \n \"Nombre Comuna\": \"Comuna\",\n \"Código Región\": \"Region ID\",\n \"Código Provincia\": \"Provincia ID\",\n \"Código Comuna 2017\": \"Comuna ID\"\n})\n\ndf[\"Casos Confirmados\"] = df[\"Casos Confirmados\"].fillna(\"-\")\n\ndf[\"Tasa\"] = df.apply(lambda x: (100000 * int(x[\"Casos Confirmados\"]) / x[\"Poblacion\"]) if x[\"Casos Confirmados\"] != \"-\" else \"-\", axis=1) \n\n# Crea output de datos en CSV / JSON\ndf.to_csv(\"../output/producto6/bulk/producto2.csv\", index=False)\ndf.to_json(\"../output/producto6/bulk/producto2.json\", orient=\"records\")"
] | [
[
"pandas.read_csv",
"pandas.read_excel",
"pandas.concat"
]
] |
streeve/PI3NN | [
"f7f08a195096e0388bb9230bc67c6acd6f41581a",
"f7f08a195096e0388bb9230bc67c6acd6f41581a",
"f7f08a195096e0388bb9230bc67c6acd6f41581a"
] | [
"NeurIPS_2021/Figure_1/DER_cubic/trainers/evidential_V2.py",
"NeurIPS_2021/Figure_1/DER_cubic/trainers/bbbp.py",
"ICLR_2022/Flight_delay/PIVEN/PIVEN_flight_delay.py"
] | [
"import numpy as np\nimport tensorflow as tf\nimport time\nimport datetime\nimport os\nimport sys\nimport h5py\nfrom pathlib import Path\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nimport evidential_deep_learning as edl\nfrom .util import normalize, gallery\n\nclass Evidential:\n def __init__(self, model, opts, dataset=\"\", learning_rate=1e-3, lam=0.0, epsilon=1e-2, maxi_rate=1e-4, tag=\"\", custom_plot_folder=\"\", custom_best_results_dat_folder=\"\"):\n self.nll_loss_function = edl.losses.NIG_NLL\n self.reg_loss_function = edl.losses.NIG_Reg\n\n self.model = model\n self.learning_rate = learning_rate\n self.maxi_rate = maxi_rate\n\n self.optimizer = tf.optimizers.Adam(self.learning_rate)\n self.lam = tf.Variable(lam)\n\n self.epsilon = epsilon\n\n self.min_rmse = self.running_rmse = float('inf')\n self.min_nll = self.running_nll = float('inf')\n self.min_vloss = self.running_vloss = float('inf')\n\n trainer = self.__class__.__name__\n current_time = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n self.save_dir = os.path.join('save','{}_{}_{}_{}'.format(current_time, dataset, trainer, tag))\n Path(self.save_dir).mkdir(parents=True, exist_ok=True)\n\n self.custom_plot_folder = custom_plot_folder\n Path(self.custom_plot_folder).mkdir(parents=True, exist_ok=True)\n ''' Create 4 folders for valid/test plots for Epistemic/Aleatoric uncertainty'''\n Path(self.custom_plot_folder + '/valid_epistemic').mkdir(parents=True, exist_ok=True)\n Path(self.custom_plot_folder + '/valid_aleatoric').mkdir(parents=True, exist_ok=True)\n Path(self.custom_plot_folder + '/test_epistemic').mkdir(parents=True, exist_ok=True)\n Path(self.custom_plot_folder + '/test_aleatoric').mkdir(parents=True, exist_ok=True)\n\n self.custom_best_results_dat_folder = custom_best_results_dat_folder\n Path(self.custom_best_results_dat_folder).mkdir(parents=True, exist_ok=True)\n\n train_log_dir = os.path.join('logs', '{}_{}_{}_{}_train'.format(current_time, dataset, trainer, tag))\n self.train_summary_writer = tf.summary.create_file_writer(train_log_dir)\n val_log_dir = os.path.join('logs', '{}_{}_{}_{}_val'.format(current_time, dataset, trainer, tag))\n self.val_summary_writer = tf.summary.create_file_writer(val_log_dir)\n\n def loss_function(self, y, mu, v, alpha, beta, reduce=True, return_comps=False):\n nll_loss = self.nll_loss_function(y, mu, v, alpha, beta, reduce=reduce)\n reg_loss = self.reg_loss_function(y, mu, v, alpha, beta, reduce=reduce)\n loss = nll_loss + self.lam * (reg_loss - self.epsilon)\n # loss = nll_loss\n\n return (loss, (nll_loss, reg_loss)) if return_comps else loss\n\n @tf.function\n def run_train_step(self, x, y):\n with tf.GradientTape() as tape:\n outputs = self.model(x, training=True)\n mu, v, alpha, beta = tf.split(outputs, 4, axis=-1)\n loss, (nll_loss, reg_loss) = self.loss_function(y, mu, v, alpha, beta, return_comps=True)\n\n grads = tape.gradient(loss, self.model.trainable_variables) #compute gradient\n self.optimizer.apply_gradients(zip(grads, self.model.trainable_variables))\n self.lam = self.lam.assign_add(self.maxi_rate * (reg_loss - self.epsilon)) #update lambda\n\n return loss, nll_loss, reg_loss, mu, v, alpha, beta\n\n @tf.function\n def evaluate(self, x, y):\n outputs = self.model(x, training=False)\n mu, v, alpha, beta = tf.split(outputs, 4, axis=-1)\n\n rmse = edl.losses.RMSE(y, mu)\n loss, (nll, reg_loss) = self.loss_function(y, mu, v, alpha, beta, return_comps=True)\n\n return mu, v, alpha, beta, loss, rmse, nll, reg_loss\n\n def normalize(self, x):\n return tf.divide(tf.subtract(x, tf.reduce_min(x)),\n tf.subtract(tf.reduce_max(x), tf.reduce_min(x)))\n\n\n def save_train_summary(self, loss, x, y, y_hat, v, alpha, beta):\n # np.random.seed(1234)\n with self.train_summary_writer.as_default():\n tf.summary.scalar('mse', tf.reduce_mean(edl.losses.MSE(y, y_hat)), step=self.iter)\n tf.summary.scalar('loss', tf.reduce_mean(self.loss_function(y, y_hat, v, alpha, beta)), step=self.iter)\n # pass\n idx = np.random.choice(int(tf.shape(x)[0]), 9) ### !!! give different model predictions !!!!!\n if tf.shape(x).shape==4:\n tf.summary.image(\"x\", [gallery(tf.gather(x,idx).numpy())], max_outputs=1, step=self.iter)\n\n if tf.shape(y).shape==4:\n tf.summary.image(\"y\", [gallery(tf.gather(y,idx).numpy())], max_outputs=1, step=self.iter)\n tf.summary.image(\"y_hat\", [gallery(tf.gather(y_hat,idx).numpy())], max_outputs=1, step=self.iter)\n\n # ''' Add additional saving for predicted y_hat and y_var '''\n # def save_train_summary_scalar(self, loss, x, y, y_hat, v, alpha, beta):\n # with self.train_summary_writer.as_default():\n # tf.summary.scalar('mse', tf.reduce_mean(edl.losses.MSE(y, y_hat)), step=self.iter)\n # tf.summary.scalar('loss', tf.reduce_mean(self.loss_function(y, y_hat, v, alpha, beta)), step=self.iter)\n # # tf.summary.scalar('y_hat_2', y_hat, step=self.iter)\n # # var = beta / (v * (alpha - 1))\n # # tf.summary.scalar('var', var, step=self.iter)\n # idx = np.random.choice(int(tf.shape(x)[0]), 9)\n # if tf.shape(x).shape == 4:\n # tf.summary.image(\"x\", [gallery(tf.gather(x, idx).numpy())], max_outputs=1, step=self.iter)\n #\n # if tf.shape(y).shape == 4:\n # tf.summary.image(\"y\", [gallery(tf.gather(y, idx).numpy())], max_outputs=1, step=self.iter)\n # tf.summary.image(\"y_hat\", [gallery(tf.gather(y_hat, idx).numpy())], max_outputs=1, step=self.iter)\n\n def save_val_summary(self, loss, x, y, mu, v, alpha, beta):\n with self.val_summary_writer.as_default():\n tf.summary.scalar('mse', tf.reduce_mean(edl.losses.MSE(y, mu)), step=self.iter)\n tf.summary.scalar('loss', tf.reduce_mean(self.loss_function(y, mu, v, alpha, beta)), step=self.iter)\n idx = np.random.choice(int(tf.shape(x)[0]), 9)\n\n # var = beta / (v * (alpha - 1))\n # print('--Type of v: {}'.format(type(v)))\n # print('--Type of alpha: {}'.format(type(alpha)))\n # print('--Type of beta: {}'.format(type(beta)))\n # print('--Type of var: {}'.format(type(var)))\n\n if tf.shape(x).shape==4:\n tf.summary.image(\"x\", [gallery(tf.gather(x,idx).numpy())], max_outputs=1, step=self.iter)\n\n if tf.shape(y).shape==4:\n tf.summary.image(\"y\", [gallery(tf.gather(y,idx).numpy())], max_outputs=1, step=self.iter)\n tf.summary.image(\"y_hat\", [gallery(tf.gather(mu,idx).numpy())], max_outputs=1, step=self.iter)\n var = beta/(v*(alpha-1))\n tf.summary.image(\"y_var\", [gallery(normalize(tf.gather(var,idx)).numpy())], max_outputs=1, step=self.iter)\n\n def get_batch(self, x, y, batch_size):\n idx = np.random.choice(x.shape[0], batch_size, replace=False)\n if isinstance(x, tf.Tensor):\n x_ = x[idx,...]\n y_ = y[idx,...]\n elif isinstance(x, np.ndarray) or isinstance(x, h5py.Dataset):\n idx = np.sort(idx)\n x_ = x[idx,...]\n y_ = y[idx,...]\n\n x_divisor = 255. if x_.dtype == np.uint8 else 1.0\n y_divisor = 255. if y_.dtype == np.uint8 else 1.0\n\n x_ = tf.convert_to_tensor(x_/x_divisor, tf.float32)\n y_ = tf.convert_to_tensor(y_/y_divisor, tf.float32)\n else:\n print(\"unknown dataset type {} {}\".format(type(x), type(y)))\n return x_, y_\n\n def save(self, name):\n self.model.save(os.path.join(self.save_dir, \"{}.h5\".format(name)))\n\n def update_running(self, previous, current, alpha=0.0):\n if previous == float('inf'):\n new = current\n else:\n new = alpha*previous + (1-alpha)*current\n return new\n\n\n ''' Siyan added for testing plot '''\n def plot_scatter_with_var_from_pandas(self, x_train, y_train, x_test, y_test, mu, var, path, n_stds=3, test_bounds=[[-7, +7]], show=True):\n plt.scatter(x_train, y_train, s=1., c='#463c3c', zorder=0, label='Train (x_train vs y_train)')\n for k in np.linspace(0, n_stds, 4):\n if k == 0:\n plt.fill_between(x_test[:, 0], (mu - k * var), (mu + k * var), alpha=0.3, edgecolor=None,\n facecolor='#00aeef', linewidth=0, antialiased=True, zorder=1, label='Unc.')\n else:\n plt.fill_between(x_test[:, 0], (mu - k * var), (mu + k * var), alpha=0.3, edgecolor=None,\n facecolor='#00aeef', linewidth=0, antialiased=True, zorder=1)\n\n plt.plot(x_test, y_test, 'r--', zorder=2, label='True (x_test vs y_test)')\n plt.plot(x_test, mu, color='#007cab', zorder=3, label='Pred (x_test vs mu)')\n plt.gca().set_xlim(*test_bounds)\n plt.gca().set_ylim(-150, 150)\n plt.title(path)\n plt.legend()\n # print('asdfsdafdsafdsafsdafdsaf')\n # print(path)\n plt.savefig(path, transparent=True)\n if show:\n plt.show()\n plt.clf()\n\n ''' Siyan added for testing plot V2 '''\n def plot_scatter_with_var_from_pandas_v2(self, iter, x_train, y_train, x_test, y_test, mu, var, path, n_stds=3, test_bounds=[[-7, +7]], evalType='valid', uq='epistemic', show=True, save=False):\n # print(path)\n plt.scatter(x_train, y_train, s=1., c='#463c3c', zorder=0, label='Train (x_train vs y_train)')\n idxx = np.argsort(x_test.flatten())\n x_test = x_test.flatten()[idxx]\n y_test = y_test.flatten()[idxx]\n # mu = mu.numpy().flatten()[idxx]\n mu = mu.flatten()[idxx]\n var = var.flatten()[idxx]\n for k in np.linspace(0, n_stds, 4):\n if k == 0:\n plt.fill_between(x_test, (mu - k * var), (mu + k * var), alpha=0.3, edgecolor=None,\n facecolor='#00aeef', linewidth=0, antialiased=True, zorder=1, label='Unc.')\n else:\n plt.fill_between(x_test, (mu - k * var), (mu + k * var), alpha=0.3, edgecolor=None,\n facecolor='#00aeef', linewidth=0, antialiased=True, zorder=1)\n\n # idxx = np.argsort(x_test.flatten())\n # print(idxx)\n # plt.plot(x_test.flatten()[idxx], y_test.flatten()[idxx], 'r--', zorder=2, label='True (x_test vs y_test)')\n # plt.plot(x_test.flatten()[idxx], mu.flatten()[idxx], color='#007cab', zorder=3, label='Pred (x_test vs mu)')\n\n if evalType == 'valid':\n plt.plot(x_test, y_test, 'r--', zorder=2, label='True (x_valid vs y_valid)')\n plt.plot(x_test, mu, color='#007cab', zorder=3, label='Pred (x_valid vs mu)')\n elif evalType == 'test':\n plt.plot(x_test, y_test, 'r--', zorder=2, label='True (x_test vs y_test)')\n plt.plot(x_test, mu, color='#007cab', zorder=3, label='Pred (x_test vs mu)')\n\n plt.gca().set_xlim(*test_bounds)\n plt.gca().set_ylim(-150, 150)\n plt.title(path)\n if uq == 'epistemic':\n plt.suptitle('Epistemic uncertainty of {} data (Iters: {})\\n'.format(evalType, iter), fontsize=18)\n elif uq == 'aleatoric':\n plt.suptitle('Aleatoric uncertainty of {} data (Iters: {})\\n'.format(evalType, iter), fontsize=18)\n\n plt.legend()\n if save:\n plt.savefig(path)\n if show:\n plt.show()\n plt.clf()\n\n\n\n def train(self, x_train, y_train, x_test, y_test, x_valid, y_valid, y_scale, batch_size=128, iters=10000, verbose=True):\n ''' Siyan added START '''\n # np.random.seed(1234)\n test_eval_count = 0\n valid_eval_count = 0\n test_best_iter_str = '0'\n valid_best_iter_str = '0'\n\n x_valid_input = tf.convert_to_tensor(x_valid, tf.float32)\n y_valid_input = tf.convert_to_tensor(y_valid, tf.float32)\n\n ''' Siyan added END '''\n tic = time.time()\n for self.iter in range(iters):\n x_input_batch, y_input_batch = self.get_batch(x_train, y_train, batch_size)\n loss, nll_loss, reg_loss, y_hat, v, alpha, beta = self.run_train_step(x_input_batch, y_input_batch)\n\n # if self.iter % 10 == 0:\n # # np.random.seed(1234)\n # self.save_train_summary(loss, x_input_batch, y_input_batch, y_hat, v, alpha, beta)\n # # self.save_train_summary_scalar(loss, x_input_batch, y_input_batch, y_hat, v, alpha, beta)\n #\n if self.iter % 10 == 0:\n x_test_batch, y_test_batch = self.get_batch(x_test, y_test, min(100, x_test.shape[0]))\n mu, v, alpha, beta, vloss, rmse, nll, reg_loss = self.evaluate(x_test_batch, y_test_batch)\n\n nll += np.log(y_scale[0, 0])\n rmse *= y_scale[0, 0]\n\n ## validation summary\n self.save_val_summary(vloss, x_test_batch, y_test_batch, mu, v, alpha, beta)\n\n self.running_rmse = self.update_running(self.running_rmse, rmse.numpy())\n if self.running_rmse < self.min_rmse:\n self.min_rmse = self.running_rmse\n # self.save(f\"model_rmse_{self.iter}\")\n\n self.running_nll = self.update_running(self.running_nll, nll.numpy())\n if self.running_nll < self.min_nll:\n self.min_nll = self.running_nll\n # self.save(f\"model_nll_{self.iter}\")\n\n self.running_vloss = self.update_running(self.running_vloss, vloss.numpy())\n if self.running_vloss < self.min_vloss:\n self.min_vloss = self.running_vloss\n # self.save(f\"model_vloss_{self.iter}\")\n\n # if verbose: print(\n # \"[A {}] RMSE: {:.4f} \\t NLL: {:.4f} \\t loss: {:.4f} \\t reg_loss: {:.4f} \\t lambda: {:.2f} \\t t: {:.2f} sec\".format(\n # self.iter, self.min_rmse, self.min_nll, vloss, reg_loss.numpy().mean(), self.lam.numpy(),\n # time.time() - tic))\n\n\n\n # ### Loss function for reference\n # def loss_function(self, y, mu, v, alpha, beta, reduce=True, return_comps=False):\n # nll_loss = self.nll_loss_function(y, mu, v, alpha, beta, reduce=reduce)\n # reg_loss = self.reg_loss_function(y, mu, v, alpha, beta, reduce=reduce)\n # loss = nll_loss + self.lam * (reg_loss - self.epsilon)\n # return (loss, (nll_loss, reg_loss)) if return_comps else loss\n\n\n if self.iter % 10 == 0:\n # self.save_train_summary(loss, x_input_batch, y_input_batch, y_hat, v, alpha, beta)\n\n\n ''' Siyan Test START --- (for entire test data instead of batch of test data)'''\n x_test_input = tf.convert_to_tensor(x_test, tf.float32)\n y_test_input = tf.convert_to_tensor(y_test, tf.float32)\n tmp_outputs_1 = self.model(x_test_input, training=False)\n test_mu, test_v, test_alpha, test_beta = tf.split(tmp_outputs_1, 4, axis=1)\n test_rmse = edl.losses.RMSE(y_test_input, test_mu)\n\n ### Calculate loss for all training data instead of a batch of training data\n test_loss, (test_nll_loss, test_reg_loss) = self.loss_function(y_test_input, test_mu, test_v, test_alpha, test_beta, return_comps=True)\n # print(test_reg_loss)\n if test_eval_count == 0:\n tmp_test_loss = test_loss\n else:\n if test_loss < tmp_test_loss:\n tmp_test_loss = test_loss\n print(\"[{}] Test loss: {:.6f} \\t RMSE: {:.4f} \\t NLL: {:.4f} \\t reg_loss: {:.4f} \\t lambda: {:.2f}\".\n format(self.iter, test_loss, test_rmse.numpy(), test_nll_loss.numpy(), test_reg_loss.numpy(), self.lam.numpy()))\n ### update the DataFrame\n test_results_df = pd.DataFrame({\n 'test_x': list(x_test.flatten()),\n 'test_y': list(y_test.flatten()),\n 'test_mu': list(test_mu.numpy().flatten()),\n 'test_v': list(test_v.numpy().flatten()),\n 'test_alpha': list(test_alpha.numpy().flatten()),\n 'test_beta': list(test_beta.numpy().flatten()),\n })\n test_best_iter_str = str(self.iter)\n test_eval_count += 1\n ''' Siyan Test END --- (for entire test data instead of batch of test data)'''\n\n ''' Siyan Test START --- (for entire validation data instead of batch of validation data)'''\n tmp_outputs_2 = self.model(x_valid_input, training=False)\n valid_mu, valid_v, valid_alpha, valid_beta = tf.split(tmp_outputs_2, 4, axis=1)\n valid_rmse = edl.losses.RMSE(y_valid_input, valid_mu)\n\n valid_loss, (valid_nll_loss, valid_reg_loss) = self.loss_function(y_valid_input, valid_mu, valid_v,\n valid_alpha, valid_beta,\n return_comps=True)\n\n # print(\"[{}] Valid loss: {:.6f} \\t RMSE: {:.4f} \\t NLL: {:.4f} \\t reg_loss: {:.4f} \\t lambda: {:.2f}\".\n # format(self.iter, valid_loss, valid_rmse.numpy(), valid_nll_loss.numpy(), valid_reg_loss.numpy(),\n # self.lam.numpy()))\n\n if valid_eval_count == 0:\n tmp_valid_loss = valid_loss\n # tmp_valid_rmse = valid_rmse\n else:\n if valid_loss < tmp_valid_loss:\n # if valid_rmse < tmp_valid_rmse:\n tmp_valid_loss = valid_loss\n # tmp_valid_rmse = valid_rmse\n print(\"[{}] Valid loss: {:.6f} \\t RMSE: {:.4f} \\t NLL: {:.4f} \\t reg_loss: {:.4f} \\t lambda: {:.2f}\".\n format(self.iter, valid_loss, valid_rmse.numpy(), valid_nll_loss.numpy(), valid_reg_loss.numpy(), self.lam.numpy()))\n ### update the DataFrame\n valid_results_df = pd.DataFrame({\n 'valid_x': list(x_valid.flatten()),\n 'valid_y': list(y_valid.flatten()),\n 'valid_mu': list(valid_mu.numpy().flatten()),\n 'valid_v': list(valid_v.numpy().flatten()),\n 'valid_alpha': list(valid_alpha.numpy().flatten()),\n 'valid_beta': list(valid_beta.numpy().flatten()),\n })\n valid_best_iter_str = str(self.iter)\n\n # valid_results_df = pd.DataFrame({\n # 'valid_x': list(x_valid.flatten()),\n # 'valid_y': list(y_valid.flatten()),\n # 'valid_mu': list(valid_mu.numpy().flatten()),\n # 'valid_v': list(valid_v.numpy().flatten()),\n # 'valid_alpha': list(valid_alpha.numpy().flatten()),\n # 'valid_beta': list(va.lid_beta.numpy().flatten()),\n # })\n valid_eval_count += 1\n\n ''' Siyan Test END --- (for entire validation data instead of batch of validation data)'''\n test_results_df.to_csv(self.custom_best_results_dat_folder + \"/best_test_results_iter_\"+test_best_iter_str+\".dat\", sep=\" \")\n print('--- Saved testing results to '+self.custom_best_results_dat_folder+'/best_test_results_iter_'+test_best_iter_str+\".dat\")\n valid_results_df.to_csv(self.custom_best_results_dat_folder + \"/best_valid_results_iter_\"+valid_best_iter_str+\".dat\", sep=\" \")\n print('--- Saved validation results to '+self.custom_best_results_dat_folder +'/best_valid_results_iter_'+valid_best_iter_str+\".dat\")\n\n ''' Test/validation results calculation and plotting:\n (1) Best train results; (2) Best validation results. And compare to the original results\n '''\n load_test_df = pd.read_csv(self.custom_best_results_dat_folder + \"/best_test_results_iter_\"+test_best_iter_str+\".dat\", sep=\" \")\n load_valid_df = pd.read_csv(self.custom_best_results_dat_folder + \"/best_valid_results_iter_\"+valid_best_iter_str+\".dat\", sep=\" \")\n\n epistemic_test = np.sqrt(load_test_df['test_beta'].values / (load_test_df['test_v'].values * (load_test_df['test_alpha'].values - 1)))\n epistemic_test = np.minimum(epistemic_test, 1e3) # clip the unc for vis\n\n print(load_test_df)\n epistemic_valid = np.sqrt(load_valid_df['valid_beta'].values / (load_valid_df['valid_v'].values * (load_valid_df['valid_alpha'].values - 1)))\n epistemic_valid = np.minimum(epistemic_valid, 1e3) # clip the unc for vis\n\n valid_bounds = [[-7, +7]]\n self.plot_scatter_with_var_from_pandas(x_train, y_train, x_valid, y_valid,\n load_test_df['test_mu'].values, epistemic_test, path=self.custom_plot_folder+\"/test_plot.pdf\", n_stds=3, test_bounds=valid_bounds, show=True)\n self.plot_scatter_with_var_from_pandas(x_train, y_train, x_valid, y_valid,\n load_valid_df['valid_mu'].values, epistemic_valid, path=self.custom_plot_folder+\"/valid_plot.pdf\", n_stds=3, test_bounds=valid_bounds, show=True)\n\n\n return self.model, self.min_rmse, self.min_nll\n\n\n # def train(self, x_train, y_train, x_test, y_test, x_valid, y_valid, y_scale, batch_size=128, iters=10000, verbose=True):\n def train_v2(self, x_train, y_train, x_valid, y_valid, x_test, y_test, y_scale, batch_size=128, iters=10000, verbose=True):\n ''' Siyan added START '''\n # np.random.seed(1234)\n valid_eval_count = 0\n valid_best_iter_str = '0'\n test_eval_count = 0\n test_best_iter_str = '0'\n\n x_test_input = tf.convert_to_tensor(x_test, tf.float32)\n y_test_input = tf.convert_to_tensor(y_test, tf.float32)\n\n ''' Siyan added END '''\n tic = time.time()\n for self.iter in range(iters):\n x_input_batch, y_input_batch = self.get_batch(x_train, y_train, batch_size)\n loss, nll_loss, reg_loss, y_hat, v, alpha, beta = self.run_train_step(x_input_batch, y_input_batch)\n\n if self.iter % 10 == 0:\n # np.random.seed(1234)\n self.save_train_summary(loss, x_input_batch, y_input_batch, y_hat, v, alpha, beta)\n # self.save_train_summary_scalar(loss, x_input_batch, y_input_batch, y_hat, v, alpha, beta)\n\n if self.iter % 10 == 0:\n x_valid_batch, y_valid_batch = self.get_batch(x_valid, y_valid, min(100, x_valid.shape[0]))\n mu, v, alpha, beta, vloss, rmse, nll, reg_loss = self.evaluate(x_valid_batch, y_valid_batch)\n\n nll += np.log(y_scale[0, 0])\n rmse *= y_scale[0, 0]\n\n ## validation summary\n self.save_val_summary(vloss, x_valid_batch, y_valid_batch, mu, v, alpha, beta)\n\n self.running_rmse = self.update_running(self.running_rmse, rmse.numpy())\n if self.running_rmse < self.min_rmse:\n self.min_rmse = self.running_rmse\n # self.save(f\"model_rmse_{self.iter}\")\n\n self.running_nll = self.update_running(self.running_nll, nll.numpy())\n if self.running_nll < self.min_nll:\n self.min_nll = self.running_nll\n # self.save(f\"model_nll_{self.iter}\")\n\n self.running_vloss = self.update_running(self.running_vloss, vloss.numpy())\n if self.running_vloss < self.min_vloss:\n self.min_vloss = self.running_vloss\n # self.save(f\"model_vloss_{self.iter}\")\n\n # if verbose: print(\n # \"[A {}] RMSE: {:.4f} \\t NLL: {:.4f} \\t loss: {:.4f} \\t reg_loss: {:.4f} \\t lambda: {:.2f} \\t t: {:.2f} sec\".format(\n # self.iter, self.min_rmse, self.min_nll, vloss, reg_loss.numpy().mean(), self.lam.numpy(),\n # time.time() - tic))\n\n # ### Loss function for reference\n # def loss_function(self, y, mu, v, alpha, beta, reduce=True, return_comps=False):\n # nll_loss = self.nll_loss_function(y, mu, v, alpha, beta, reduce=reduce)\n # reg_loss = self.reg_loss_function(y, mu, v, alpha, beta, reduce=reduce)\n # loss = nll_loss + self.lam * (reg_loss - self.epsilon)\n # return (loss, (nll_loss, reg_loss)) if return_comps else loss\n\n\n if self.iter % 10 == 0 or self.iter < 50 or self.iter >= iters - 50:\n # self.save_train_summary(loss, x_input_batch, y_input_batch, y_hat, v, alpha, beta)\n\n ''' Siyan Test START --- (for all validation dat)'''\n x_valid_input = tf.convert_to_tensor(x_valid, tf.float32)\n y_valid_input = tf.convert_to_tensor(y_valid, tf.float32)\n tmp_outputs_1 = self.model(x_valid_input, training=False)\n valid_mu, valid_v, valid_alpha, valid_beta = tf.split(tmp_outputs_1, 4, axis=1)\n valid_rmse = edl.losses.RMSE(y_valid_input, valid_mu)\n\n ### Calculate loss for batch validation data\n valid_loss, (valid_nll_loss, valid_reg_loss) = self.loss_function(y_valid_input, valid_mu, valid_v, valid_alpha, valid_beta, return_comps=True)\n\n\n ### Calculate Epistemic, Aleatoric uncertainty for validation data directly and plot\n ''' epistemic (Var[mu]) = beta/ (v(alpha - 1)) '''\n epistemic_valid = np.sqrt(valid_beta / (valid_v * (valid_alpha - 1)))\n aleatoric_sigma_valid = np.sqrt((epistemic_valid ** 2) * valid_v)\n epistemic_valid = np.minimum(epistemic_valid, 1e3) # clip the unc for vis\n aleatoric_sigma_valid = np.minimum(aleatoric_sigma_valid, 1e3) # clip the unc for vis\n test_bounds = [[-7, +7]]\n\n ### x_train, y_train: np_arr (size, 1)\n ### x_valid, y_valid: np_arr (size, 1)\n ### valid_mu: tf tensor (size, 1)\n ### epistemic_valid: np_arr (size, 1)\n valid_mu_np = valid_mu.numpy()\n self.plot_scatter_with_var_from_pandas_v2(self.iter, x_train, y_train, x_valid, y_valid, valid_mu_np, epistemic_valid,\n path=self.custom_plot_folder+\"/valid_epistemic\"+\"/valid_plot_iter_{}\".format(self.iter)+\".png\",\n n_stds=3, test_bounds=test_bounds, evalType='valid', uq='epistemic', show=False, save=True)\n self.plot_scatter_with_var_from_pandas_v2(self.iter, x_train, y_train, x_valid, y_valid, valid_mu_np, aleatoric_sigma_valid,\n path=self.custom_plot_folder+\"/valid_aleatoric\"+\"/valid_plot_iter_{}\".format(self.iter)+\".png\",\n n_stds=3, test_bounds=test_bounds, evalType='valid', uq='aleatoric', show=False, save=True)\n\n # # print(valid_reg_loss)\n if valid_eval_count == 0:\n tmp_valid_loss = valid_loss\n else:\n if valid_loss < tmp_valid_loss:\n tmp_valid_loss = valid_loss\n print(\"[{}] Valid loss: {:.6f} \\t RMSE: {:.4f} \\t NLL: {:.4f} \\t reg_loss: {:.4f} \\t lambda: {:.2f}\".\n format(self.iter, valid_loss, valid_rmse.numpy(), valid_nll_loss.numpy(), valid_reg_loss.numpy(), self.lam.numpy()))\n ### update the DataFrame\n valid_results_df = pd.DataFrame({\n 'valid_x': list(x_valid.flatten()),\n 'valid_y': list(y_valid.flatten()),\n 'valid_mu': list(valid_mu.numpy().flatten()),\n 'valid_v': list(valid_v.numpy().flatten()),\n 'valid_alpha': list(valid_alpha.numpy().flatten()),\n 'valid_beta': list(valid_beta.numpy().flatten()),\n })\n valid_best_iter_str = str(self.iter)\n valid_eval_count += 1\n ''' Siyan Test END --- (for all validation data)'''\n\n ''' Siyan Test START --- (for entire testing data)'''\n tmp_outputs_2 = self.model(x_test_input, training=False)\n test_mu, test_v, test_alpha, test_beta = tf.split(tmp_outputs_2, 4, axis=1)\n test_rmse = edl.losses.RMSE(y_test_input, test_mu)\n\n test_loss, (test_nll_loss, test_reg_loss) = self.loss_function(y_test_input, test_mu, test_v,\n test_alpha, test_beta,\n return_comps=True)\n\n ### Calculate Epistemic, Aleatoric uncertainty for test data directly and plot\n ''' epistemic (Var[mu]) = beta/ (v(alpha - 1)) '''\n epistemic_test = np.sqrt(test_beta / (test_v * (test_alpha - 1)))\n aleatoric_sigma_test = np.sqrt((epistemic_test ** 2) * test_v)\n epistemic_test = np.minimum(epistemic_test, 1e3) # clip the unc for vis\n aleatoric_sigma_test = np.minimum(aleatoric_sigma_test, 1e3) # clip the unc for vis\n test_bounds = [[-7, +7]]\n\n test_mu_np = test_mu.numpy()\n self.plot_scatter_with_var_from_pandas_v2(self.iter, x_train, y_train, x_test, y_test, test_mu_np, epistemic_test,\n path=self.custom_plot_folder+\"/test_epistemic\"+\"/test_plot_iter_{}\".format(self.iter)+\".png\",\n n_stds=3, test_bounds=test_bounds, evalType='test', uq='epistemic', show=False, save=True)\n self.plot_scatter_with_var_from_pandas_v2(self.iter, x_train, y_train, x_test, y_test, test_mu_np, aleatoric_sigma_test,\n path=self.custom_plot_folder+\"/test_aleatoric\"+\"/test_plot_iter_{}\".format(self.iter)+\".png\",\n n_stds=3, test_bounds=test_bounds, evalType='test', uq='aleatoric', show=False, save=True)\n\n # print(\"[{}] Valid loss: {:.6f} \\t RMSE: {:.4f} \\t NLL: {:.4f} \\t reg_loss: {:.4f} \\t lambda: {:.2f}\".\n # format(self.iter, valid_loss, valid_rmse.numpy(), valid_nll_loss.numpy(), valid_reg_loss.numpy(),\n # self.lam.numpy()))\n\n # test_mu_np = test_mu.numpy()\n # self.plot_scatter_with_var_from_pandas_v2(self.iter, x_train, y_train, x_test, y_test, test_mu_np, epistemic_test,\n # path=self.custom_plot_folder+\"/test_plot_iter_{}\".format(self.iter)+\".png\",\n # n_stds=3, test_bounds=test_bounds, evalType='test', uq='epistemic', show=False, save=True)\n\n if test_eval_count == 0:\n tmp_test_loss = test_loss\n # tmp_valid_rmse = valid_rmse\n else:\n if test_loss < tmp_test_loss:\n # if valid_rmse < tmp_valid_rmse:\n tmp_test_loss = test_loss\n # tmp_valid_rmse = valid_rmse\n print(\"[{}] Test loss: {:.6f} \\t RMSE: {:.4f} \\t NLL: {:.4f} \\t reg_loss: {:.4f} \\t lambda: {:.2f}\".\n format(self.iter, test_loss, test_rmse.numpy(), test_nll_loss.numpy(), test_reg_loss.numpy(), self.lam.numpy()))\n ### update the DataFrame\n test_results_df = pd.DataFrame({\n 'test_x': list(x_test.flatten()),\n 'test_y': list(y_test.flatten()),\n 'test_mu': list(test_mu.numpy().flatten()),\n 'test_v': list(test_v.numpy().flatten()),\n 'test_alpha': list(test_alpha.numpy().flatten()),\n 'test_beta': list(test_beta.numpy().flatten()),\n })\n test_best_iter_str = str(self.iter)\n test_eval_count += 1\n\n ''' Siyan Test END --- (for entire test data)'''\n\n valid_results_df.to_csv(self.custom_best_results_dat_folder + \"/best_valid_results_iter_\"+valid_best_iter_str+\".dat\", sep=\" \")\n print('--- Saved validation results to '+self.custom_best_results_dat_folder +'/best_valid_results_iter_'+valid_best_iter_str+\".dat\")\n test_results_df.to_csv(self.custom_best_results_dat_folder + \"/best_test_results_iter_\"+test_best_iter_str+\".dat\", sep=\" \")\n print('--- Saved testing results to '+self.custom_best_results_dat_folder+'/best_test_results_iter_'+test_best_iter_str+\".dat\")\n\n\n ''' Validation/test results calculation and plotting:\n (1) Best validation results; (2) Best testing results. And compare to the original results\n '''\n load_valid_df = pd.read_csv(self.custom_best_results_dat_folder + \"/best_valid_results_iter_\"+valid_best_iter_str+\".dat\", sep=\" \")\n load_test_df = pd.read_csv(self.custom_best_results_dat_folder + \"/best_test_results_iter_\"+test_best_iter_str+\".dat\", sep=\" \")\n\n ''' epistemic (Var[mu]) = beta/ (v(alpha - 1)) '''\n epistemic_valid = np.sqrt(load_valid_df['valid_beta'].values / (load_valid_df['valid_v'].values * (load_valid_df['valid_alpha'].values - 1)))\n epistemic_valid = np.minimum(epistemic_valid, 1e3) # clip the unc for vis\n\n epistemic_test = np.sqrt(load_test_df['test_beta'].values / (load_test_df['test_v'].values * (load_test_df['test_alpha'].values - 1)))\n epistemic_test = np.minimum(epistemic_test, 1e3) # clip the unc for vis\n\n ''' aleatoric (E[sigma^2]) = beta / (alpha - 1)'''\n # aleatoric_valid_sigma = np.sqrt()\n\n # print(load_test_df)\n\n # valid_bounds = [[-4, +4]]\n test_bounds = [[-7, +7]]\n\n # print(x_train.shape)\n # print(y_train.shape)\n # print(x_valid.shape)\n # print(y_valid.shape)\n # print(load_valid_df['valid_mu'].values.shape)\n # print(epistemic_valid.shape)\n\n\n # self.plot_scatter_with_var_from_pandas_v2(x_train, y_train, x_valid, y_valid,\n # load_valid_df['valid_mu'].values, epistemic_valid, path=self.custom_plot_folder+\"/valid_plot.pdf\", n_stds=3, test_bounds=test_bounds, show=True)\n\n #\n # self.plot_scatter_with_var_from_pandas_v2(x_train, y_train, x_test, y_test,\n # load_test_df['test_mu'].values, epistemic_test, path=self.custom_plot_folder+\"/test_plot.pdf\", n_stds=3, test_bounds=test_bounds, show=True)\n\n return self.model, self.min_rmse, self.min_nll\n",
"import numpy as np\nimport tensorflow as tf\nimport tensorflow_probability as tfp\nimport time\nimport datetime\nimport os\nimport sys\nimport h5py\nfrom pathlib import Path\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nimport evidential_deep_learning as edl\nfrom .util import normalize, gallery\n\nclass BBBP:\n def __init__(self, model, opts, dataset=\"\", learning_rate=1e-3, tag=\"\", custom_plot_folder=\"\", custom_best_results_dat_folder=\"\"):\n self.loss_function = edl.losses.MSE\n\n self.model = model\n\n self.optimizer = tf.optimizers.Adam(learning_rate)\n\n self.min_rmse = float('inf')\n self.min_nll = float('inf')\n self.min_vloss = float('inf')\n\n trainer = self.__class__.__name__\n current_time = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n self.save_dir = os.path.join('save','{}_{}_{}_{}'.format(current_time, dataset, trainer, tag))\n Path(self.save_dir).mkdir(parents=True, exist_ok=True)\n\n self.custom_plot_folder = custom_plot_folder\n Path(self.custom_plot_folder).mkdir(parents=True, exist_ok=True)\n\n self.custom_best_results_dat_folder = custom_best_results_dat_folder\n Path(self.custom_best_results_dat_folder).mkdir(parents=True, exist_ok=True)\n\n\n train_log_dir = os.path.join('logs', '{}_{}_{}_{}_train'.format(current_time, dataset, trainer, tag))\n self.train_summary_writer = tf.summary.create_file_writer(train_log_dir)\n val_log_dir = os.path.join('logs', '{}_{}_{}_{}_val'.format(current_time, dataset, trainer, tag))\n self.val_summary_writer = tf.summary.create_file_writer(val_log_dir)\n\n @tf.function\n def run_train_step(self, x, y):\n with tf.GradientTape() as tape:\n y_hat = self.model(x, training=True) #forward pass\n loss = self.loss_function(y, y_hat)\n loss += tf.reduce_mean(self.model.losses)\n\n grads = tape.gradient(loss, self.model.variables) #compute gradient\n self.optimizer.apply_gradients(zip(grads, self.model.variables))\n return loss, y_hat\n\n @tf.function\n def evaluate(self, x, y):\n preds = tf.stack([self.model(x, training=True) for _ in range(5)], axis=0) #forward pass\n mu, var = tf.nn.moments(preds, axes=0)\n rmse = edl.losses.RMSE(y, mu)\n nll = edl.losses.Gaussian_NLL(y, mu, tf.sqrt(var))\n loss = self.loss_function(y, mu)\n\n return mu, var, loss, rmse, nll\n\n @tf.function\n def siyan_bbbp_evaluate(self, x_input):\n preds = tf.stack([self.model(x_input, training=True) for _ in range(15)], axis=0) # forward pass\n mean_mu = tf.reduce_mean(preds, axis=0)\n epistemic = tf.math.reduce_std(preds, axis=0)\n return mean_mu, epistemic\n\n def save_train_summary(self, loss, x, y, y_hat):\n with self.train_summary_writer.as_default():\n # tf.summary.scalar('loss', tf.reduce_mean(loss), step=self.iter)\n tf.summary.scalar('mse', tf.reduce_mean(edl.losses.MSE(y, y_hat)), step=self.iter)\n idx = np.random.choice(int(tf.shape(x)[0]), 9)\n if tf.shape(x).shape==4:\n tf.summary.image(\"x\", [gallery(tf.gather(x,idx).numpy())], max_outputs=1, step=self.iter)\n\n if tf.shape(y).shape==4:\n tf.summary.image(\"y\", [gallery(tf.gather(y,idx).numpy())], max_outputs=1, step=self.iter)\n tf.summary.image(\"y_hat\", [gallery(tf.gather(y_hat,idx).numpy())], max_outputs=1, step=self.iter)\n\n def save_val_summary(self, loss, x, y, mu, var):\n with self.val_summary_writer.as_default():\n tf.summary.scalar('loss', tf.reduce_mean(self.loss_function(y, mu)), step=self.iter)\n tf.summary.scalar('mse', tf.reduce_mean(edl.losses.MSE(y, mu)), step=self.iter)\n idx = np.random.choice(int(tf.shape(x)[0]), 9)\n if tf.shape(x).shape==4:\n tf.summary.image(\"x\", [gallery(tf.gather(x,idx).numpy())], max_outputs=1, step=self.iter)\n\n if tf.shape(y).shape==4:\n tf.summary.image(\"y\", [gallery(tf.gather(y,idx).numpy())], max_outputs=1, step=self.iter)\n tf.summary.image(\"y_hat\", [gallery(tf.gather(mu,idx).numpy())], max_outputs=1, step=self.iter)\n tf.summary.image(\"y_var\", [gallery(normalize(tf.gather(var,idx)).numpy())], max_outputs=1, step=self.iter)\n\n def get_batch(self, x, y, batch_size):\n idx = np.random.choice(x.shape[0], batch_size, replace=False)\n if isinstance(x, tf.Tensor):\n x_ = x[idx,...]\n y_ = y[idx,...]\n elif isinstance(x, np.ndarray) or isinstance(x, h5py.Dataset):\n idx = np.sort(idx)\n x_ = x[idx,...]\n y_ = y[idx,...]\n\n x_divisor = 255. if x_.dtype == np.uint8 else 1.0\n y_divisor = 255. if y_.dtype == np.uint8 else 1.0\n\n x_ = tf.convert_to_tensor(x_/x_divisor, tf.float32)\n y_ = tf.convert_to_tensor(y_/y_divisor, tf.float32)\n else:\n print(\"unknown dataset type {} {}\".format(type(x), type(y)))\n return x_, y_\n\n def save(self, name):\n self.model.save(os.path.join(self.save_dir, \"{}.h5\".format(name)))\n # pass\n\n ''' Siyan added for testing plot '''\n def plot_scatter_with_var_from_pandas(self, x_train, y_train, x_test, y_test, mu, var, path, n_stds=3, test_bounds=[[-7, +7]], show=True):\n plt.scatter(x_train, y_train, s=1., c='#463c3c', zorder=0, label='Train (x_train vs y_train)')\n for k in np.linspace(0, n_stds, 4):\n if k == 0:\n plt.fill_between(x_test[:, 0], (mu - k * var), (mu + k * var), alpha=0.3, edgecolor=None,\n facecolor='#00aeef', linewidth=0, antialiased=True, zorder=1, label='Unc.')\n else:\n plt.fill_between(x_test[:, 0], (mu - k * var), (mu + k * var), alpha=0.3, edgecolor=None,\n facecolor='#00aeef', linewidth=0, antialiased=True, zorder=1)\n\n plt.plot(x_test, y_test, 'r--', zorder=2, label='True (x_test vs y_test)')\n plt.plot(x_test, mu, color='#007cab', zorder=3, label='Pred (x_test vs mu)')\n plt.gca().set_xlim(*test_bounds)\n plt.gca().set_ylim(-150, 150)\n plt.title(path)\n plt.legend()\n plt.savefig(path, transparent=True)\n if show:\n plt.show()\n plt.clf()\n\n def train(self, x_train, y_train, x_test, y_test, x_valid, y_valid, y_scale, batch_size=128, iters=10000, verbose=True):\n ''' Siyan added START '''\n # np.random.seed(1234)\n test_eval_count = 0\n valid_eval_count = 0\n test_best_iter_str = '0'\n valid_best_iter_str = '0'\n\n x_valid_input = tf.convert_to_tensor(x_valid, tf.float32)\n y_valid_input = tf.convert_to_tensor(y_valid, tf.float32)\n\n tic = time.time()\n for self.iter in range(iters):\n x_input_batch, y_input_batch = self.get_batch(x_train, y_train, batch_size)\n loss, y_hat = self.run_train_step(x_input_batch, y_input_batch)\n\n if self.iter % 10 == 0:\n self.save_train_summary(loss, x_input_batch, y_input_batch, y_hat)\n\n if self.iter % 100 == 0:\n x_test_batch, y_test_batch = self.get_batch(x_test, y_test, min(100, x_test.shape[0]))\n mu, var, vloss, rmse, nll = self.evaluate(x_test_batch, y_test_batch)\n nll += np.log(y_scale[0,0])\n rmse *= y_scale[0,0]\n\n self.save_val_summary(vloss, x_test_batch, y_test_batch, mu, var)\n\n if rmse.numpy() < self.min_rmse:\n self.min_rmse = rmse.numpy()\n print(\"SAVING\")\n self.save(\"model_rmse\")\n\n if nll.numpy() < self.min_nll:\n self.min_nll = nll.numpy()\n self.save(\"model_nll\")\n\n if vloss.numpy() < self.min_vloss:\n self.min_vloss = vloss.numpy()\n self.save(\"model_vloss\")\n\n # if verbose: print(\"[{}] \\t RMSE: {:.4f} \\t NLL: {:.4f} \\t train_loss: {:.4f} \\t t: {:.2f} sec\".format(self.iter, self.min_rmse, self.min_nll, vloss, time.time()-tic))\n # tic = time.time()\n\n ''' Siyan Test START --- (for entire test data instead of batch of test data)'''\n if self.iter % 10 == 0:\n x_test_input = tf.convert_to_tensor(x_test, tf.float32)\n y_test_input = tf.convert_to_tensor(y_test, tf.float32)\n test_mu, test_var, test_vloss, test_rmse, test_nll = self.evaluate(x_test_input, y_test_input)\n if test_eval_count == 0:\n tmp_test_loss = test_vloss\n else:\n if test_vloss < tmp_test_loss:\n tmp_test_loss = test_vloss\n print(\"[{}] Test loss: {:.6f} \\t RMSE: {:.4f} \\t NLL: {:.4f} \".\n format(self.iter, test_vloss, test_rmse.numpy(), test_nll.numpy()))\n\n test_mean_mu, test_epistemic = self.siyan_bbbp_evaluate(x_test_input)\n ### update the DataFrame\n test_results_df = pd.DataFrame({\n 'test_x': list(x_test.flatten()),\n 'test_y': list(y_test.flatten()),\n 'test_mean_mu': list(test_mean_mu.numpy().flatten()),\n 'test_epistemic': list(test_epistemic.numpy().flatten())\n # 'test_mu': list(test_mu.numpy().flatten()),\n # 'test_var': list(test_var.numpy().flatten())\n })\n test_best_iter_str = str(self.iter)\n test_eval_count += 1\n ''' Siyan Test END --- (for entire test data instead of batch of test data)'''\n\n ''' Siyan Test START --- (for entire validation data instead of batch of validation data)'''\n valid_mu, valid_var, valid_vloss, valid_rmse, valid_nll = self.evaluate(x_valid_input, y_valid_input)\n if valid_eval_count == 0:\n tmp_valid_loss = valid_vloss\n else:\n if valid_vloss < tmp_valid_loss:\n tmp_valid_loss = valid_vloss\n print(\"[{}] Validation loss: {:.6f} \\t RMSE: {:.4f} \\t NLL: {:.4f} \".\n format(self.iter, valid_vloss, valid_rmse.numpy(), valid_nll.numpy()))\n\n valid_mean_mu, valid_epistemic = self.siyan_bbbp_evaluate(x_valid_input)\n ### update the DataFrame\n valid_results_df = pd.DataFrame({\n 'valid_x': list(x_valid.flatten()),\n 'valid_y': list(y_valid.flatten()),\n 'valid_mean_mu': list(valid_mean_mu.numpy().flatten()),\n 'valid_epistemic': list(valid_epistemic.numpy().flatten())\n # 'valid_mean_var': list(valid_mean_var.numpy().flatten()),\n # 'valid_reduce_std_mu': list(valid_reduce_std_mu.numpy().flatten()),\n # 'valid_reduce_mean_var': list(valid_reduce_mean_var.numpy().flatten())\n })\n valid_best_iter_str = str(self.iter)\n\n valid_eval_count += 1\n ''' Siyan Test END --- (for entire validation data instead of batch of validation data)'''\n\n test_results_df.to_csv(self.custom_best_results_dat_folder + \"/best_test_results_iter_\"+test_best_iter_str+\".dat\", sep=\" \")\n print('--- Saved testing results to '+self.custom_best_results_dat_folder+'/best_test_results_iter_'+test_best_iter_str+\".dat\")\n valid_results_df.to_csv(self.custom_best_results_dat_folder + \"/best_valid_results_iter_\"+valid_best_iter_str+\".dat\", sep=\" \")\n print('--- Saved validation results to '+self.custom_best_results_dat_folder +'/best_valid_results_iter_'+valid_best_iter_str+\".dat\")\n\n ''' Test/validation results calculation and plotting:\n (1) Best train results; (2) Best validation results. And compare to the original results\n '''\n load_test_df = pd.read_csv(self.custom_best_results_dat_folder + \"/best_test_results_iter_\"+test_best_iter_str+\".dat\", sep=\" \")\n load_valid_df = pd.read_csv(self.custom_best_results_dat_folder + \"/best_valid_results_iter_\"+valid_best_iter_str+\".dat\", sep=\" \")\n\n valid_bounds = [[-7, +7]]\n self.plot_scatter_with_var_from_pandas(x_train, y_train, x_valid, y_valid,\n load_test_df['test_mean_mu'].values, load_test_df['test_epistemic'].values, path=self.custom_plot_folder+\"/test_plot.pdf\", n_stds=3, test_bounds=valid_bounds, show=True)\n self.plot_scatter_with_var_from_pandas(x_train, y_train, x_valid, y_valid,\n load_valid_df['valid_mean_mu'].values, load_valid_df['valid_epistemic'], path=self.custom_plot_folder+\"/valid_plot.pdf\", n_stds=3, test_bounds=valid_bounds, show=True)\n\n\n\n return self.model, self.min_rmse, self.min_nll\n",
"# -*- coding: utf-8 -*-\n\"\"\"\nRun method, and save results.\nRun as:\n python main.py --dataset <ds> --method <met>\n where dataset name should be in UCI_Datasets folder\n and method is piven, qd, deep-ens, mid or only-rmse.\n\"\"\"\nimport argparse\nimport json\nimport datetime\nimport tensorflow as tf\n# import tensorflow.compat.v1 as tf\nimport scipy.stats as stats\nimport itertools\nimport os\nimport random\nimport numpy as np\n\n\nimport data_loader\nfrom DataGen import DataGenerator\nfrom DeepNetPI import TfNetwork\nfrom utils import *\nfrom sklearn.model_selection import train_test_split\n\n\nstart_time = datetime.datetime.now()\n\nparser = argparse.ArgumentParser()\nparser.add_argument('--dataset', type=str, default='flight_delay', metavar='',\n help='dataset name, flight_delay')\nparser.add_argument('--method', type=str, help='piven, qd, mid, only-rmse, deep-ens', required=True)\nargs = parser.parse_args()\nmethod = args.method\n\n############# added code start ############# \nprint(args)\nprint(args.dataset)\noriginal_data_path = '../flight_delay_data/' ## flight delay data\nresults_path = './Results/piven/'+args.dataset + '_PIVEN_UCI.txt'\n\n\nseed = 12345\nneurons = [100]\nlambda_in = 15.0\nsigma_in = 0.2\n\nrandom.seed(seed)\nnp.random.seed(seed)\ntf.compat.v1.random.set_random_seed(seed)\n# tf.random.set_random_seed(seed)\nh_size = neurons\n\n\n# n_runs = params['n_runs'] # number of runs\nn_runs = 1\nn_epoch = 500 # number epochs to train for\n# h_size = params['h_size'] # number of hidden units in network: [50]=layer_1 of 50, [8,4]=layer_1 of 8, layer_2 of 4\nl_rate = 0.01 # learning rate of optimizer\ndecay_rate = 0.99 # learning rate decay\nsoften = 160.0 # soften param in the loss\npatience = -1 # patience\nn_ensemble = 1 # number of individual NNs in ensemble # 5\nalpha = 0.05 # data points captured = (1 - alpha)\ntrain_prop = 0.9 # % of data to use as training\nin_ddof = 1 if n_runs > 1 else 0 # this is for results over runs only\nis_early_stop = patience != -1\n\nif args.dataset == 'YearPredictionMSD':\n n_batch = 1000 # batch size\n out_biases = [5., -5.]\nelse:\n n_batch = 100 # batch size\n out_biases = [2., -2.] # chose biases for output layer (for deep_ens is overwritten to 0,1)\n\n\nresults_runs = []\nrun = 0\nfail_times = 0\nfor run in range(0, n_runs):\n\n\n ''' ######### flight delay data loading ###############'''\n xTrain, yTrain, test_data_list = data_loader.load_flight_delays(original_data_path)\n\n # y_train = np.reshape(y_train, (-1, 1))\n # y_test = np.reshape(y_test, (-1, 1))\n\n '''choose the train/test dataset '''\n x_train = xTrain\n y_train = yTrain\n y_train = y_train.reshape(-1, 1)\n # y_scale = yTrain_scale\n test_idx = 0 # [0, 1, 2, 3] for test 1,2,3,4\n X_test = test_data_list[test_idx][0]\n y_test = test_data_list[test_idx][1]\n y_test = y_test.reshape(-1, 1)\n\n\n X_val = X_test\n y_val = y_test.reshape(-1, 1)\n\n\n y_pred_all = []\n y_pred_all_train = []\n\n i = 0\n while i < n_ensemble:\n is_failed_run = False\n\n tf.reset_default_graph()\n sess = tf.Session()\n\n print(f'\\nrun number {run+1} of {n_runs} -- ensemble number {i+1} of {n_ensemble}')\n\n # create network\n NN = TfNetwork(x_size=x_train.shape[1],\n y_size=2,\n h_size=h_size,\n alpha=alpha,\n soften=soften,\n lambda_in=lambda_in,\n sigma_in=sigma_in,\n out_biases=out_biases,\n method=method,\n patience=patience,\n dataset=args.dataset,\n rnd_seed=seed)\n\n # train\n NN.train(sess, x_train, y_train, X_val, y_val,\n n_epoch=n_epoch,\n l_rate=l_rate,\n decay_rate=decay_rate,\n is_early_stop=is_early_stop,\n n_batch=n_batch)\n\n # predict\n y_loss, y_pred = NN.predict(sess, X_test=X_test, y_test=y_test)\n\n # prediction for training data\n y_loss_train, y_pred_train = NN.predict(sess, X_test=x_train, y_test=y_train)\n\n # check whether the run failed or not\n if np.abs(y_loss) > 20. and fail_times < 1: # jump out of some endless failures\n # if False:\n is_failed_run = True\n fail_times+=1\n print('\\n\\n### one messed up! repeating ensemble ### failed {}/5 times!'.format(fail_times))\n continue # without saving result\n else:\n i += 1 # continue to next\n\n # save prediction\n y_pred_all.append(y_pred)\n y_pred_all_train.append(y_pred_train)\n sess.close()\n\n y_pred_all = np.array(y_pred_all)\n y_pred_all_train = np.array(y_pred_all_train)\n\n if method == 'deep-ens':\n y_pred_gauss_mid_all = y_pred_all[:, :, 0]\n # occasionally may get -ves for std dev so need to do max\n y_pred_gauss_dev_all = np.sqrt(np.maximum(np.log(1. + np.exp(y_pred_all[:, :, 1])), 10e-6))\n y_pred_gauss_mid, y_pred_gauss_dev, y_pred_U, \\\n y_pred_L = gauss_to_pi(y_pred_gauss_mid_all, y_pred_gauss_dev_all)\n\n else:\n ### for test data\n y_pred_gauss_mid, y_pred_gauss_dev, y_pred_U, y_pred_L, y_pred_v = pi_to_gauss(y_pred_all, method=method)\n ### for training data\n y_pred_gauss_mid_train, y_pred_gauss_dev_train, y_pred_U_train, y_pred_L_train, y_pred_v_train = pi_to_gauss(y_pred_all_train, method=method)\n \n\n ### calculate the confidence scores \n # for train\n y_U_cap_train = y_pred_U_train > y_train.reshape(-1)\n y_L_cap_train = y_pred_L_train < y_train.reshape(-1)\n MPIW_array_train = y_pred_U_train - y_pred_L_train \n MPIW_train = np.mean(MPIW_array_train)\n\n MPIW_array_test = y_pred_U - y_pred_L\n\n confidence_arr_test = [min(MPIW_train/test_width, 1.0) for test_width in MPIW_array_test]\n confidence_arr_train = [min(MPIW_train/train_width, 1.0) for train_width in MPIW_array_train]\n\n print('----------- OOD analysis --- confidence scores ----------------')\n print('--- Train conf_scores MEAN: {}, STD: {}'.format(np.mean(confidence_arr_train), np.std(confidence_arr_train)))\n print('--- Test: {} rank: {} conf_scores MEAN: {}, STD: {}'.format(test_idx+1, test_idx+1, np.mean(confidence_arr_test), np.std(confidence_arr_test)))\n\n dist_arr_train = np.sqrt(np.sum(x_train ** 2.0, axis=1))\n dist_arr_test = np.sqrt(np.sum(X_val ** 2.0, axis=1))\n\n confidence_arr_train = np.array(confidence_arr_train)\n confidence_arr_test = np.array(confidence_arr_test)\n\n PIVEN_OOD_train_np = np.hstack((dist_arr_train.reshape(-1, 1), confidence_arr_train.reshape(-1, 1)))\n PIVEN_OOD_test_np = np.hstack((dist_arr_test.reshape(-1, 1), confidence_arr_test.reshape(-1, 1)))\n\n np.savetxt('PIVEN_OOD_flight_delay_'+ str(test_idx+1) +'_train_np.txt', PIVEN_OOD_train_np, delimiter=',')\n np.savetxt('PIVEN_OOD_flight_delay_'+ str(test_idx+1) +'_test_np.txt', PIVEN_OOD_test_np, delimiter=',')\n\n # # work out metrics\n # y_U_cap = y_pred_U > y_test.reshape(-1)\n # y_L_cap = y_pred_L < y_test.reshape(-1)\n\n # y_all_cap = y_U_cap * y_L_cap\n # PICP = np.sum(y_all_cap) / y_L_cap.shape[0]\n # MPIW = np.mean(y_pred_U - y_pred_L)\n # y_pred_mid = np.mean((y_pred_U, y_pred_L), axis=0)\n # # MSE = np.mean(np.square(Gen.scale_c * (y_pred_mid - y_test[:, 0])))\n # # RMSE = np.sqrt(MSE)\n\n # if method == 'qd' or method == 'deep-ens':\n # RMSE_ELI = 0.0 # RMSE_PIVEN\n # else:\n # if method == 'piven':\n # y_piven = y_pred_v * y_pred_U + (1 - y_pred_v) * y_pred_L\n\n # elif method == 'mid':\n # y_piven = 0.5 * y_pred_U + 0.5 * y_pred_L\n\n # elif method == 'only-rmse':\n # y_piven = y_pred_v\n\n # MSE_ELI = np.mean(np.square(Gen.scale_c * (y_piven - y_test[:, 0])))\n # RMSE_ELI = np.sqrt(MSE_ELI) # RMSE_PIVEN\n\n # CWC = np_QD_loss(y_test, y_pred_L, y_pred_U, alpha, lambda_in) # from qd paper.\n # neg_log_like = gauss_neg_log_like(y_test, y_pred_gauss_mid, y_pred_gauss_dev, Gen.scale_c)\n # residuals = y_pred_mid - y_test[:, 0]\n # shapiro_W, shapiro_p = stats.shapiro(residuals[:])\n # results_runs.append((PICP, MPIW, CWC, RMSE, RMSE_ELI, neg_log_like, shapiro_W, shapiro_p))\n\n# # summarize results\n# results_path = f\"./Results/{method}/\"\n# results_path += f\"{params['dataset']}-{start_time.strftime('%d-%m-%H-%M')}-{method}.csv\"\n\n# results = np.array(results_runs)\n# results_to_csv(results_path, results, params, n_runs, n_ensemble, in_ddof)\n\n# timing info\nend_time = datetime.datetime.now()\ntotal_time = end_time - start_time\nprint('\\n\\nminutes taken:', round(total_time.total_seconds() / 60, 3),\n '\\nstart_time:', start_time.strftime('%H:%M:%S'),\n 'end_time:', end_time.strftime('%H:%M:%S'))\n"
] | [
[
"tensorflow.reduce_max",
"numpy.log",
"tensorflow.convert_to_tensor",
"tensorflow.Variable",
"matplotlib.pyplot.plot",
"tensorflow.split",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.gca",
"numpy.random.choice",
"matplotlib.pyplot.title",
"tensorflow.GradientTape",
"tensorflow.reduce_min",
"numpy.linspace",
"matplotlib.pyplot.scatter",
"numpy.minimum",
"tensorflow.shape",
"pandas.read_csv",
"matplotlib.pyplot.clf",
"numpy.sort",
"matplotlib.pyplot.fill_between",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show",
"numpy.sqrt",
"tensorflow.gather",
"tensorflow.optimizers.Adam",
"tensorflow.summary.create_file_writer"
],
[
"tensorflow.math.reduce_std",
"numpy.log",
"tensorflow.convert_to_tensor",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.gca",
"numpy.random.choice",
"matplotlib.pyplot.title",
"tensorflow.GradientTape",
"numpy.linspace",
"matplotlib.pyplot.scatter",
"tensorflow.shape",
"pandas.read_csv",
"matplotlib.pyplot.clf",
"numpy.sort",
"matplotlib.pyplot.fill_between",
"tensorflow.nn.moments",
"matplotlib.pyplot.legend",
"tensorflow.sqrt",
"tensorflow.reduce_mean",
"matplotlib.pyplot.show",
"tensorflow.gather",
"tensorflow.optimizers.Adam",
"tensorflow.summary.create_file_writer"
],
[
"numpy.sum",
"numpy.random.seed",
"numpy.abs",
"numpy.exp",
"tensorflow.Session",
"numpy.array",
"numpy.std",
"tensorflow.reset_default_graph",
"tensorflow.compat.v1.random.set_random_seed",
"numpy.mean"
]
] |
savindi-wijenayaka/transformer_old | [
"016960521eaaf5393c9fad1c4db15338455213f8"
] | [
"tests/test_modeling_prophetnet.py"
] | [
"# coding=utf-8\n# Copyright 2020 The HuggingFace Inc. team, The Microsoft Research 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.\n\n\nimport copy\nimport tempfile\nimport unittest\n\nfrom transformers import is_torch_available\nfrom transformers.testing_utils import require_torch, slow, torch_device\n\nfrom .test_configuration_common import ConfigTester\nfrom .test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor\n\n\nif is_torch_available():\n import torch\n\n from transformers import (\n ProphetNetConfig,\n ProphetNetDecoder,\n ProphetNetEncoder,\n ProphetNetForCausalLM,\n ProphetNetForConditionalGeneration,\n ProphetNetModel,\n ProphetNetTokenizer,\n )\n\n\nclass ProphetNetModelTester:\n def __init__(\n self,\n parent,\n vocab_size=99,\n batch_size=13,\n hidden_size=16,\n encoder_seq_length=7,\n decoder_seq_length=9,\n # For common tests\n is_training=True,\n use_attention_mask=True,\n use_labels=True,\n decoder_start_token_id=0,\n encoder_ffn_dim=32,\n num_encoder_layers=4,\n num_encoder_attention_heads=4,\n decoder_ffn_dim=32,\n num_decoder_layers=4,\n num_decoder_attention_heads=4,\n max_position_embeddings=30,\n is_encoder_decoder=True,\n pad_token_id=0,\n bos_token_id=1,\n eos_token_id=2,\n ngram=2,\n num_buckets=32,\n relative_max_distance=128,\n disable_ngram_loss=False,\n scope=None,\n ):\n\n self.parent = parent\n self.batch_size = batch_size\n self.encoder_seq_length = encoder_seq_length\n self.decoder_seq_length = decoder_seq_length\n # For common tests\n self.seq_length = self.decoder_seq_length\n self.is_training = is_training\n self.use_attention_mask = use_attention_mask\n self.use_labels = use_labels\n\n self.vocab_size = vocab_size\n self.hidden_size = hidden_size\n self.num_hidden_layers = num_decoder_layers\n self.num_encoder_layers = num_encoder_layers\n self.num_decoder_layers = num_decoder_layers\n self.decoder_ffn_dim = decoder_ffn_dim\n self.encoder_ffn_dim = encoder_ffn_dim\n self.num_attention_heads = num_decoder_attention_heads\n self.num_encoder_attention_heads = num_encoder_attention_heads\n self.num_decoder_attention_heads = num_decoder_attention_heads\n self.eos_token_id = eos_token_id\n self.bos_token_id = bos_token_id\n self.pad_token_id = pad_token_id\n self.decoder_start_token_id = decoder_start_token_id\n self.ngram = ngram\n self.num_buckets = num_buckets\n self.relative_max_distance = relative_max_distance\n self.disable_ngram_loss = disable_ngram_loss\n self.max_position_embeddings = max_position_embeddings\n self.is_encoder_decoder = is_encoder_decoder\n\n self.scope = None\n self.decoder_key_length = decoder_seq_length\n self.base_model_out_len = 7\n self.num_hidden_states_types = 3 # encoder, decoder_main, decoder_ngram\n self.decoder_attention_idx = 2\n\n def prepare_config_and_inputs(self):\n input_ids = ids_tensor([self.batch_size, self.encoder_seq_length], self.vocab_size)\n decoder_input_ids = ids_tensor([self.batch_size, self.decoder_seq_length], self.vocab_size)\n\n attention_mask = None\n decoder_attention_mask = None\n if self.use_attention_mask:\n attention_mask = ids_tensor([self.batch_size, self.encoder_seq_length], vocab_size=2)\n decoder_attention_mask = ids_tensor([self.batch_size, self.decoder_seq_length], vocab_size=2)\n\n lm_labels = None\n if self.use_labels:\n lm_labels = ids_tensor([self.batch_size, self.decoder_seq_length], self.vocab_size)\n\n config = ProphetNetConfig(\n vocab_size=self.vocab_size,\n hidden_size=self.hidden_size,\n num_encoder_layers=self.num_encoder_layers,\n num_decoder_layers=self.num_decoder_layers,\n decoder_ffn_dim=self.decoder_ffn_dim,\n encoder_ffn_dim=self.encoder_ffn_dim,\n num_encoder_attention_heads=self.num_encoder_attention_heads,\n num_decoder_attention_heads=self.num_decoder_attention_heads,\n eos_token_id=self.eos_token_id,\n bos_token_id=self.bos_token_id,\n pad_token_id=self.pad_token_id,\n decoder_start_token_id=self.decoder_start_token_id,\n ngram=self.ngram,\n num_buckets=self.num_buckets,\n relative_max_distance=self.relative_max_distance,\n disable_ngram_loss=self.disable_ngram_loss,\n max_position_embeddings=self.max_position_embeddings,\n is_encoder_decoder=self.is_encoder_decoder,\n return_dict=True,\n )\n\n return (\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n )\n\n def prepare_config_and_inputs_for_decoder(self):\n (\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n ) = self.prepare_config_and_inputs()\n\n encoder_hidden_states = floats_tensor([self.batch_size, self.encoder_seq_length, self.hidden_size])\n encoder_attention_mask = ids_tensor([self.batch_size, self.encoder_seq_length], vocab_size=2)\n\n return (\n config,\n decoder_input_ids,\n decoder_attention_mask,\n encoder_hidden_states,\n encoder_attention_mask,\n lm_labels,\n )\n\n def check_prepare_lm_labels_via_shift_left(\n self,\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n ):\n model = ProphetNetModel(config=config)\n model.to(torch_device)\n model.eval()\n\n # make sure that lm_labels are correctly padded from the right\n lm_labels.masked_fill_((lm_labels == self.decoder_start_token_id), self.eos_token_id)\n\n # add casaul pad token mask\n triangular_mask = torch.tril(lm_labels.new_ones(lm_labels.shape)).logical_not()\n lm_labels.masked_fill_(triangular_mask, self.pad_token_id)\n decoder_input_ids = model._shift_right(lm_labels)\n\n for i, (decoder_input_ids_slice, lm_labels_slice) in enumerate(zip(decoder_input_ids, lm_labels)):\n # first item\n self.parent.assertEqual(decoder_input_ids_slice[0].item(), self.decoder_start_token_id)\n if i < decoder_input_ids_slice.shape[-1]:\n if i < decoder_input_ids.shape[-1] - 1:\n # items before diagonal\n self.parent.assertListEqual(\n decoder_input_ids_slice[1 : i + 1].tolist(), lm_labels_slice[:i].tolist()\n )\n # pad items after diagonal\n if i < decoder_input_ids.shape[-1] - 2:\n self.parent.assertListEqual(\n decoder_input_ids_slice[i + 2 :].tolist(), lm_labels_slice[i + 1 : -1].tolist()\n )\n else:\n # all items after square\n self.parent.assertListEqual(decoder_input_ids_slice[1:].tolist(), lm_labels_slice[:-1].tolist())\n\n def create_and_check_model(\n self,\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n ):\n model = ProphetNetModel(config=config)\n model.to(torch_device)\n model.eval()\n result = model(\n input_ids=input_ids,\n decoder_input_ids=decoder_input_ids,\n attention_mask=attention_mask,\n decoder_attention_mask=decoder_attention_mask,\n )\n result = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)\n decoder_output = result.last_hidden_state\n decoder_past = result.past_key_values\n encoder_output = result.encoder_last_hidden_state\n\n self.parent.assertEqual(encoder_output.size(), (self.batch_size, self.encoder_seq_length, self.hidden_size))\n self.parent.assertEqual(decoder_output.size(), (self.batch_size, self.decoder_seq_length, self.hidden_size))\n # There should be `num_layers` key value embeddings stored in decoder_past\n self.parent.assertEqual(len(decoder_past), config.num_decoder_layers)\n # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple\n self.parent.assertEqual(len(decoder_past[0]), 2) # cross-attention + uni-directional self-attention\n\n def create_and_check_with_lm_head(\n self,\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n ):\n model = ProphetNetForConditionalGeneration(config=config).to(torch_device).eval()\n outputs = model(\n input_ids=input_ids,\n decoder_input_ids=decoder_input_ids,\n decoder_attention_mask=decoder_attention_mask,\n labels=lm_labels,\n )\n self.parent.assertEqual(len(outputs), 5)\n self.parent.assertEqual(outputs[\"logits\"].size(), (self.batch_size, self.decoder_seq_length, self.vocab_size))\n self.parent.assertEqual(outputs[\"loss\"].size(), ())\n\n def create_and_check_causal_lm_decoder(\n self,\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n ):\n model = ProphetNetForCausalLM(config=config).to(torch_device).eval()\n outputs = model(\n input_ids=decoder_input_ids,\n attention_mask=decoder_attention_mask,\n labels=lm_labels,\n )\n self.parent.assertEqual(len(outputs), 4)\n self.parent.assertEqual(outputs[\"logits\"].size(), (self.batch_size, self.decoder_seq_length, self.vocab_size))\n self.parent.assertEqual(outputs[\"loss\"].size(), ())\n\n def create_and_check_generate_with_past_key_value_states(\n self,\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n ):\n model = ProphetNetForConditionalGeneration(config=config).to(torch_device).eval()\n torch.manual_seed(0)\n output_without_past_cache = model.generate(\n input_ids[:1], num_beams=2, max_length=5, do_sample=True, use_cache=False\n )\n torch.manual_seed(0)\n output_with_past_cache = model.generate(input_ids[:1], num_beams=2, max_length=5, do_sample=True)\n self.parent.assertTrue(torch.all(output_with_past_cache == output_without_past_cache))\n\n def create_and_check_model_fp16_forward(\n self,\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n ):\n model = ProphetNetModel(config=config).to(torch_device).half().eval()\n output = model(input_ids, decoder_input_ids=input_ids, attention_mask=attention_mask)[\"last_hidden_state\"]\n self.parent.assertFalse(torch.isnan(output).any().item())\n\n def create_and_check_encoder_decoder_shared_weights(\n self,\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n ):\n for model_class in [ProphetNetModel, ProphetNetForConditionalGeneration]:\n torch.manual_seed(0)\n model = model_class(config=config).to(torch_device).eval()\n # load state dict copies weights but does not tie them\n\n if model_class == ProphetNetForConditionalGeneration:\n model.prophetnet.encoder.load_state_dict(model.prophetnet.decoder.state_dict(), strict=False)\n else:\n model.encoder.load_state_dict(model.decoder.state_dict(), strict=False)\n\n torch.manual_seed(0)\n tied_config = copy.deepcopy(config)\n tied_config.tie_encoder_decoder = True\n tied_model = model_class(config=tied_config).to(torch_device).eval()\n\n model_result = model(\n input_ids=input_ids,\n decoder_input_ids=decoder_input_ids,\n attention_mask=attention_mask,\n decoder_attention_mask=decoder_attention_mask,\n return_dict=True,\n )\n\n tied_model_result = tied_model(\n input_ids=input_ids,\n decoder_input_ids=decoder_input_ids,\n attention_mask=attention_mask,\n decoder_attention_mask=decoder_attention_mask,\n return_dict=True,\n )\n\n # check that models has less parameters\n self.parent.assertLess(\n sum(p.numel() for p in tied_model.parameters()), sum(p.numel() for p in model.parameters())\n )\n random_slice_idx = ids_tensor((1,), model_result[0].shape[-1]).item()\n\n # check that outputs are equal\n self.parent.assertTrue(\n torch.allclose(\n model_result[0][0, :, random_slice_idx], tied_model_result[0][0, :, random_slice_idx], atol=1e-4\n )\n )\n\n # check that outputs after saving and loading are equal\n with tempfile.TemporaryDirectory() as tmpdirname:\n tied_model.save_pretrained(tmpdirname)\n tied_model = model_class.from_pretrained(tmpdirname)\n tied_model.to(torch_device)\n tied_model.eval()\n\n # check that models has less parameters\n self.parent.assertLess(\n sum(p.numel() for p in tied_model.parameters()), sum(p.numel() for p in model.parameters())\n )\n random_slice_idx = ids_tensor((1,), model_result[0].shape[-1]).item()\n\n tied_model_result = tied_model(\n input_ids=input_ids,\n decoder_input_ids=decoder_input_ids,\n attention_mask=attention_mask,\n decoder_attention_mask=decoder_attention_mask,\n )\n\n # check that outputs are equal\n self.parent.assertTrue(\n torch.allclose(\n model_result[0][0, :, random_slice_idx],\n tied_model_result[0][0, :, random_slice_idx],\n atol=1e-4,\n )\n )\n\n def check_fast_integration(\n self,\n config,\n *args,\n ):\n input_ids = torch.tensor([[7, 4, 78, 0, 24, 52, 43]], device=torch_device, dtype=torch.long)\n decoder_input_ids = torch.tensor([[12, 62, 25, 11, 47, 15, 14]], device=torch_device, dtype=torch.long)\n attention_mask = torch.tensor([[1, 1, 1, 0, 1, 0, 0]], device=torch_device, dtype=torch.long)\n decoder_attention_mask = torch.tensor([[1, 1, 1, 0, 0, 1, 0]], device=torch_device, dtype=torch.long)\n lm_labels = torch.tensor([[62, 25, 11, 47, 15, 14, 24]], device=torch_device, dtype=torch.long)\n torch.manual_seed(0)\n config.ngram = 4\n model = ProphetNetForConditionalGeneration(config=config)\n model.to(torch_device)\n model.eval()\n with torch.no_grad():\n result = model(\n input_ids=input_ids,\n decoder_input_ids=decoder_input_ids,\n attention_mask=attention_mask,\n decoder_attention_mask=decoder_attention_mask,\n labels=lm_labels,\n return_dict=True,\n )\n self.parent.assertTrue(torch.allclose(result.loss, torch.tensor(128.2925, device=torch_device), atol=1e-3))\n\n expected_logit_slice = torch.tensor(\n [-0.1565, 0.0418, 0.1207, 0.0030, 0.0665, 0.0467, 0.0412], device=torch_device\n )\n self.parent.assertTrue(torch.allclose(result.logits[0, :, 1], expected_logit_slice, atol=1e-3))\n\n def check_model_with_attn_mask(self, config, input_ids, decoder_input_ids, *args):\n model = ProphetNetModel(config=config)\n model.to(torch_device)\n model.eval()\n\n outputs_no_mask = model(\n input_ids=input_ids[:, :5], decoder_input_ids=decoder_input_ids[:, :5], return_dict=True\n )\n attention_mask = torch.ones_like(input_ids)\n decoder_attention_mask = torch.ones_like(decoder_input_ids)\n\n attention_mask[:, 5:] = 0\n\n outputs_with_mask = model(\n input_ids=input_ids,\n attention_mask=attention_mask,\n decoder_input_ids=decoder_input_ids,\n decoder_attention_mask=decoder_attention_mask,\n return_dict=True,\n )\n\n # check encoder\n self.parent.assertTrue(\n torch.allclose(\n outputs_no_mask.encoder_last_hidden_state[0, :, 0],\n outputs_with_mask.encoder_last_hidden_state[0, :5, 0],\n atol=1e-3,\n )\n )\n\n # check decoder\n # main stream\n self.parent.assertTrue(\n torch.allclose(\n outputs_no_mask.last_hidden_state[0, :, 0], outputs_with_mask.last_hidden_state[0, :5, 0], atol=1e-3\n )\n )\n # predict stream\n self.parent.assertTrue(\n torch.allclose(\n outputs_no_mask.last_hidden_state_ngram[0, :5, 0],\n outputs_with_mask.last_hidden_state_ngram[0, :5, 0],\n atol=1e-3,\n )\n )\n\n def prepare_config_and_inputs_for_common(self):\n config_and_inputs = self.prepare_config_and_inputs()\n (\n config,\n input_ids,\n decoder_input_ids,\n attention_mask,\n decoder_attention_mask,\n lm_labels,\n ) = config_and_inputs\n\n inputs_dict = {\n \"input_ids\": input_ids,\n \"attention_mask\": attention_mask,\n \"decoder_input_ids\": decoder_input_ids,\n \"decoder_attention_mask\": decoder_attention_mask,\n \"use_cache\": False,\n }\n return config, inputs_dict\n\n\nclass ProphetNetStandaloneDecoderModelTester:\n def __init__(\n self,\n parent,\n vocab_size=99,\n batch_size=13,\n hidden_size=16,\n encoder_seq_length=7,\n decoder_seq_length=7,\n # For common tests\n is_training=True,\n is_decoder=True,\n use_attention_mask=True,\n add_cross_attention=False,\n use_cache=False,\n use_labels=True,\n decoder_start_token_id=0,\n encoder_ffn_dim=32,\n num_encoder_layers=4,\n num_encoder_attention_heads=4,\n decoder_ffn_dim=32,\n num_decoder_layers=4,\n num_decoder_attention_heads=4,\n max_position_embeddings=30,\n is_encoder_decoder=False,\n pad_token_id=0,\n bos_token_id=1,\n eos_token_id=2,\n ngram=2,\n return_dict=True,\n num_buckets=32,\n relative_max_distance=128,\n disable_ngram_loss=False,\n scope=None,\n ):\n self.parent = parent\n self.batch_size = batch_size\n self.encoder_seq_length = encoder_seq_length\n self.decoder_seq_length = decoder_seq_length\n # For common tests\n self.seq_length = self.decoder_seq_length\n self.is_training = is_training\n self.use_attention_mask = use_attention_mask\n self.use_labels = use_labels\n\n self.vocab_size = vocab_size\n self.hidden_size = hidden_size\n self.num_hidden_layers = num_decoder_layers\n self.num_encoder_layers = num_encoder_layers\n self.num_decoder_layers = num_decoder_layers\n self.decoder_ffn_dim = decoder_ffn_dim\n self.encoder_ffn_dim = encoder_ffn_dim\n self.num_attention_heads = num_decoder_attention_heads\n self.num_encoder_attention_heads = num_encoder_attention_heads\n self.num_decoder_attention_heads = num_decoder_attention_heads\n self.eos_token_id = eos_token_id\n self.bos_token_id = bos_token_id\n self.pad_token_id = pad_token_id\n self.decoder_start_token_id = decoder_start_token_id\n self.ngram = ngram\n self.num_buckets = num_buckets\n self.relative_max_distance = relative_max_distance\n self.use_cache = use_cache\n self.disable_ngram_loss = disable_ngram_loss\n self.max_position_embeddings = max_position_embeddings\n self.add_cross_attention = add_cross_attention\n self.is_encoder_decoder = is_encoder_decoder\n self.return_dict = return_dict\n\n self.scope = None\n self.decoder_key_length = decoder_seq_length\n self.base_model_out_len = 2\n self.num_hidden_states_types = 2 # decoder_main, decoder_ngram\n self.decoder_attention_idx = 1\n\n def prepare_config_and_inputs(self):\n input_ids = ids_tensor([self.batch_size, self.encoder_seq_length], self.vocab_size)\n\n attention_mask = None\n if self.use_attention_mask:\n attention_mask = ids_tensor([self.batch_size, self.encoder_seq_length], vocab_size=2)\n\n lm_labels = None\n if self.use_labels:\n lm_labels = ids_tensor([self.batch_size, self.encoder_seq_length], self.vocab_size)\n\n config = ProphetNetConfig(\n vocab_size=self.vocab_size,\n hidden_size=self.hidden_size,\n num_encoder_layers=self.num_encoder_layers,\n num_decoder_layers=self.num_decoder_layers,\n decoder_ffn_dim=self.decoder_ffn_dim,\n encoder_ffn_dim=self.encoder_ffn_dim,\n num_encoder_attention_heads=self.num_encoder_attention_heads,\n num_decoder_attention_heads=self.num_decoder_attention_heads,\n eos_token_id=self.eos_token_id,\n bos_token_id=self.bos_token_id,\n use_cache=self.use_cache,\n pad_token_id=self.pad_token_id,\n decoder_start_token_id=self.decoder_start_token_id,\n ngram=self.ngram,\n num_buckets=self.num_buckets,\n relative_max_distance=self.relative_max_distance,\n disable_ngram_loss=self.disable_ngram_loss,\n max_position_embeddings=self.max_position_embeddings,\n add_cross_attention=self.add_cross_attention,\n is_encoder_decoder=self.is_encoder_decoder,\n return_dict=self.return_dict,\n )\n\n return (\n config,\n input_ids,\n attention_mask,\n lm_labels,\n )\n\n def prepare_config_and_inputs_for_decoder(self):\n (\n config,\n input_ids,\n attention_mask,\n lm_labels,\n ) = self.prepare_config_and_inputs()\n\n encoder_hidden_states = floats_tensor([self.batch_size, self.encoder_seq_length, self.hidden_size])\n encoder_attention_mask = ids_tensor([self.batch_size, self.encoder_seq_length], vocab_size=2)\n\n return (\n config,\n input_ids,\n attention_mask,\n encoder_hidden_states,\n encoder_attention_mask,\n lm_labels,\n )\n\n def create_and_check_decoder_model_past(\n self,\n config,\n input_ids,\n attention_mask,\n lm_labels,\n ):\n config.use_cache = True\n model = ProphetNetDecoder(config=config).to(torch_device).eval()\n # first forward pass\n outputs = model(input_ids, use_cache=True)\n outputs_use_cache_conf = model(input_ids)\n outputs_no_past = model(input_ids, use_cache=False)\n\n self.parent.assertTrue(len(outputs) == len(outputs_use_cache_conf))\n self.parent.assertTrue(len(outputs) == len(outputs_no_past) + 1)\n\n past_key_values = outputs[\"past_key_values\"]\n\n # create hypothetical next token and extent to next_input_ids\n next_tokens = ids_tensor((self.batch_size, 1), config.vocab_size)\n\n # append to next input_ids and\n next_input_ids = torch.cat([input_ids, next_tokens], dim=-1)\n\n output_from_no_past = model(next_input_ids)[\"last_hidden_state\"]\n output_from_past = model(next_tokens, past_key_values=past_key_values)[\"last_hidden_state\"]\n\n # select random slice\n random_slice_idx = ids_tensor((1,), output_from_past.shape[-1]).item()\n output_from_no_past_slice = output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()\n output_from_past_slice = output_from_past[:, 0, random_slice_idx].detach()\n\n # test that outputs are equal for slice\n assert torch.allclose(output_from_past_slice, output_from_no_past_slice, atol=1e-3)\n\n def create_and_check_decoder_model_attention_mask_past(\n self,\n config,\n input_ids,\n attention_mask,\n lm_labels,\n ):\n model = ProphetNetDecoder(config=config).to(torch_device).eval()\n\n # create attention mask\n attn_mask = torch.ones(input_ids.shape, dtype=torch.long, device=torch_device)\n\n half_seq_length = input_ids.shape[-1] // 2\n attn_mask[:, half_seq_length:] = 0\n\n # first forward pass\n past_key_values = model(input_ids, attention_mask=attn_mask, use_cache=True)[\"past_key_values\"]\n\n # create hypothetical next token and extent to next_input_ids\n next_tokens = ids_tensor((self.batch_size, 1), config.vocab_size)\n\n # change a random masked slice from input_ids\n random_seq_idx_to_change = ids_tensor((1,), half_seq_length).item() + 1\n random_other_next_tokens = ids_tensor((self.batch_size, 1), config.vocab_size).squeeze(-1)\n input_ids[:, -random_seq_idx_to_change] = random_other_next_tokens\n\n # append to next input_ids and attn_mask\n next_input_ids = torch.cat([input_ids, next_tokens], dim=-1)\n attn_mask = torch.cat(\n [attn_mask, torch.ones((attn_mask.shape[0], 1), dtype=torch.long, device=torch_device)],\n dim=1,\n )\n\n # get two different outputs\n output_from_no_past = model(next_input_ids)[\"last_hidden_state\"]\n output_from_past = model(next_tokens, past_key_values=past_key_values)[\"last_hidden_state\"]\n\n # select random slice\n random_slice_idx = ids_tensor((1,), output_from_past.shape[-1]).item()\n output_from_no_past_slice = output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()\n output_from_past_slice = output_from_past[:, 0, random_slice_idx].detach()\n\n # test that outputs are equal for slice\n assert torch.allclose(output_from_past_slice, output_from_no_past_slice, atol=1e-2)\n\n def prepare_config_and_inputs_for_common(self):\n config_and_inputs = self.prepare_config_and_inputs()\n (\n config,\n input_ids,\n attention_mask,\n lm_labels,\n ) = config_and_inputs\n\n inputs_dict = {\n \"input_ids\": input_ids,\n \"attention_mask\": attention_mask,\n }\n return config, inputs_dict\n\n\nclass ProphetNetStandaloneEncoderModelTester:\n def __init__(\n self,\n parent,\n vocab_size=99,\n batch_size=13,\n hidden_size=16,\n encoder_seq_length=7,\n decoder_seq_length=7,\n # For common tests\n is_training=True,\n is_decoder=False,\n use_attention_mask=True,\n add_cross_attention=False,\n use_cache=False,\n use_labels=True,\n decoder_start_token_id=0,\n encoder_ffn_dim=32,\n num_encoder_layers=4,\n num_encoder_attention_heads=4,\n decoder_ffn_dim=32,\n num_decoder_layers=4,\n num_decoder_attention_heads=4,\n max_position_embeddings=30,\n is_encoder_decoder=False,\n pad_token_id=0,\n bos_token_id=1,\n eos_token_id=2,\n return_dict=True,\n num_buckets=32,\n relative_max_distance=128,\n disable_ngram_loss=False,\n scope=None,\n ):\n self.parent = parent\n self.batch_size = batch_size\n self.encoder_seq_length = encoder_seq_length\n self.decoder_seq_length = decoder_seq_length\n # For common tests\n self.seq_length = self.decoder_seq_length\n self.is_training = is_training\n self.use_attention_mask = use_attention_mask\n self.use_labels = use_labels\n\n self.vocab_size = vocab_size\n self.hidden_size = hidden_size\n self.num_hidden_layers = num_decoder_layers\n self.num_encoder_layers = num_encoder_layers\n self.num_decoder_layers = num_decoder_layers\n self.decoder_ffn_dim = decoder_ffn_dim\n self.encoder_ffn_dim = encoder_ffn_dim\n self.num_attention_heads = num_decoder_attention_heads\n self.num_encoder_attention_heads = num_encoder_attention_heads\n self.num_decoder_attention_heads = num_decoder_attention_heads\n self.eos_token_id = eos_token_id\n self.bos_token_id = bos_token_id\n self.pad_token_id = pad_token_id\n self.decoder_start_token_id = decoder_start_token_id\n self.num_buckets = num_buckets\n self.relative_max_distance = relative_max_distance\n self.use_cache = use_cache\n self.disable_ngram_loss = disable_ngram_loss\n self.max_position_embeddings = max_position_embeddings\n self.add_cross_attention = add_cross_attention\n self.is_encoder_decoder = is_encoder_decoder\n self.return_dict = return_dict\n\n self.scope = None\n self.decoder_key_length = decoder_seq_length\n self.base_model_out_len = 1\n self.num_hidden_states_types = 1\n self.decoder_attention_idx = 1\n\n def prepare_config_and_inputs(self):\n input_ids = ids_tensor([self.batch_size, self.encoder_seq_length], self.vocab_size)\n\n attention_mask = None\n if self.use_attention_mask:\n attention_mask = ids_tensor([self.batch_size, self.encoder_seq_length], vocab_size=2)\n\n config = ProphetNetConfig(\n vocab_size=self.vocab_size,\n hidden_size=self.hidden_size,\n num_encoder_layers=self.num_encoder_layers,\n num_decoder_layers=self.num_decoder_layers,\n decoder_ffn_dim=self.decoder_ffn_dim,\n encoder_ffn_dim=self.encoder_ffn_dim,\n num_encoder_attention_heads=self.num_encoder_attention_heads,\n num_decoder_attention_heads=self.num_decoder_attention_heads,\n eos_token_id=self.eos_token_id,\n bos_token_id=self.bos_token_id,\n use_cache=self.use_cache,\n pad_token_id=self.pad_token_id,\n decoder_start_token_id=self.decoder_start_token_id,\n num_buckets=self.num_buckets,\n relative_max_distance=self.relative_max_distance,\n disable_ngram_loss=self.disable_ngram_loss,\n max_position_embeddings=self.max_position_embeddings,\n add_cross_attention=self.add_cross_attention,\n is_encoder_decoder=self.is_encoder_decoder,\n return_dict=self.return_dict,\n )\n\n return (\n config,\n input_ids,\n attention_mask,\n )\n\n def prepare_config_and_inputs_for_common(self):\n config_and_inputs = self.prepare_config_and_inputs()\n (\n config,\n input_ids,\n attention_mask,\n ) = config_and_inputs\n\n inputs_dict = {\n \"input_ids\": input_ids,\n \"attention_mask\": attention_mask,\n }\n return config, inputs_dict\n\n\n@require_torch\nclass ProphetNetModelTest(ModelTesterMixin, unittest.TestCase):\n all_model_classes = (ProphetNetModel, ProphetNetForConditionalGeneration) if is_torch_available() else ()\n all_generative_model_classes = (ProphetNetForConditionalGeneration,) if is_torch_available() else ()\n test_pruning = False\n test_torchscript = False\n test_resize_embeddings = False\n test_headmasking = False\n is_encoder_decoder = True\n\n def setUp(self):\n self.model_tester = ProphetNetModelTester(self)\n self.config_tester = ConfigTester(self, config_class=ProphetNetConfig)\n\n def test_config(self):\n self.config_tester.run_common_tests()\n\n def test_model(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.create_and_check_model(*config_and_inputs)\n\n def test_lm_model(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.create_and_check_with_lm_head(*config_and_inputs)\n\n def test_only_decoder_causal_model(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.create_and_check_causal_lm_decoder(*config_and_inputs)\n\n def test_fast_integration(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.check_fast_integration(*config_and_inputs)\n\n def test_shared_weights(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.create_and_check_encoder_decoder_shared_weights(*config_and_inputs)\n\n def test_shift_labels_via_shift_left(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.check_prepare_lm_labels_via_shift_left(*config_and_inputs)\n\n def test_decoder_model_generate(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.create_and_check_generate_with_past_key_value_states(*config_and_inputs)\n\n def test_attn_mask_model(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.check_model_with_attn_mask(*config_and_inputs)\n\n def test_config_save(self):\n config = self.model_tester.prepare_config_and_inputs()[0]\n config.add_cross_attention = False\n with tempfile.TemporaryDirectory() as tmp_dirname:\n config.save_pretrained(tmp_dirname)\n config = ProphetNetConfig.from_pretrained(tmp_dirname)\n\n self.assertFalse(config.add_cross_attention)\n\n @unittest.skipIf(torch_device == \"cpu\", \"Cant do half precision\")\n def test_fp16_forward(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.create_and_check_model_fp16_forward(*config_and_inputs)\n\n\n@require_torch\nclass ProphetNetStandaloneDecoderModelTest(ModelTesterMixin, unittest.TestCase):\n all_model_classes = (ProphetNetDecoder, ProphetNetForCausalLM) if is_torch_available() else ()\n all_generative_model_classes = (ProphetNetForCausalLM,) if is_torch_available() else ()\n test_pruning = False\n test_torchscript = False\n test_resize_embeddings = False\n test_headmasking = False\n is_encoder_decoder = False\n\n def setUp(self):\n self.model_tester = ProphetNetStandaloneDecoderModelTester(self)\n self.config_tester = ConfigTester(self, config_class=ProphetNetConfig)\n\n def test_config(self):\n self.config_tester.run_common_tests()\n\n def test_decoder_model_past(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.create_and_check_decoder_model_past(*config_and_inputs)\n\n def test_decoder_model_attn_mask_past(self):\n config_and_inputs = self.model_tester.prepare_config_and_inputs()\n self.model_tester.create_and_check_decoder_model_attention_mask_past(*config_and_inputs)\n\n\n@require_torch\nclass ProphetNetStandaloneEncoderModelTest(ModelTesterMixin, unittest.TestCase):\n all_model_classes = (ProphetNetEncoder,) if is_torch_available() else ()\n test_pruning = False\n test_torchscript = False\n test_resize_embeddings = False\n test_headmasking = False\n is_encoder_decoder = False\n\n def setUp(self):\n self.model_tester = ProphetNetStandaloneEncoderModelTester(self)\n self.config_tester = ConfigTester(self, config_class=ProphetNetConfig)\n\n def test_config(self):\n self.config_tester.run_common_tests()\n\n\n@require_torch\nclass ProphetNetModelIntegrationTest(unittest.TestCase):\n @slow\n def test_pretrained_checkpoint_hidden_states(self):\n model = ProphetNetForConditionalGeneration.from_pretrained(\"microsoft/prophetnet-large-uncased\")\n model.to(torch_device)\n\n # encoder-decoder outputs\n encoder_ids = torch.tensor(\n [\n [\n 2871,\n 102,\n 2048,\n 3176,\n 2780,\n 1997,\n 2871,\n 26727,\n 2169,\n 2097,\n 12673,\n 1996,\n 8457,\n 2006,\n 2049,\n 8240,\n 2859,\n 2799,\n 1012,\n 2023,\n 6512,\n 2038,\n 2174,\n 13977,\n 2195,\n 25962,\n 1012,\n 102,\n ]\n ]\n ).to(torch_device)\n\n decoder_prev_ids = torch.tensor([[102, 2129, 2116, 2372, 2024, 2006, 2169, 1997, 2122, 2048, 2780, 1029]]).to(\n torch_device\n )\n output = model(\n input_ids=encoder_ids,\n attention_mask=None,\n encoder_outputs=None,\n decoder_input_ids=decoder_prev_ids,\n return_dict=True,\n )\n output_predited_logits = output[0]\n expected_shape = torch.Size((1, 12, 30522))\n self.assertEqual(output_predited_logits.shape, expected_shape)\n expected_slice = torch.tensor(\n [[[-7.6213, -7.9008, -7.9979], [-7.6834, -7.8467, -8.2187], [-7.5326, -7.4762, -8.1914]]]\n ).to(torch_device)\n # self.assertTrue(torch.allclose(output_predited_logits[:, :3, :3], expected_slice, atol=1e-4))\n assert torch.allclose(output_predited_logits[:, :3, :3], expected_slice, atol=1e-4)\n\n # encoder outputs\n encoder_outputs = model.prophetnet.encoder(encoder_ids)[0]\n expected_encoder_outputs_slice = torch.tensor(\n [[[-0.2526, -0.1951, -0.2185], [-0.8923, 0.2992, -0.4623], [-0.4585, 0.0165, -0.6652]]]\n ).to(torch_device)\n expected_shape_encoder = torch.Size((1, 28, 1024))\n self.assertEqual(encoder_outputs.shape, expected_shape_encoder)\n # self.assertTrue(torch.allclose(encoder_outputs[:, :3, :3], expected_encoder_outputs_slice, atol=1e-4))\n assert torch.allclose(encoder_outputs[:, :3, :3], expected_encoder_outputs_slice, atol=1e-4)\n\n # decoder outputs\n decoder_outputs = model.prophetnet.decoder(\n decoder_prev_ids, encoder_hidden_states=encoder_outputs, return_dict=True\n )\n predicting_streams = decoder_outputs[1].view(1, model.config.ngram, 12, -1)\n predicting_streams_logits = model.lm_head(predicting_streams)\n next_first_stream_logits = predicting_streams_logits[:, 0]\n # self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3], expected_slice, atol=1e-4))\n assert torch.allclose(next_first_stream_logits[:, :3, :3], expected_slice, atol=1e-4)\n\n @slow\n def test_cnndm_inference(self):\n model = ProphetNetForConditionalGeneration.from_pretrained(\"microsoft/prophetnet-large-uncased-cnndm\")\n model.config.max_length = 512\n model.to(torch_device)\n\n tokenizer = ProphetNetTokenizer.from_pretrained(\"microsoft/prophetnet-large-uncased-cnndm\")\n\n ARTICLE_TO_SUMMARIZE = \"USTC was founded in Beijing by the Chinese Academy of Sciences (CAS) in September 1958. The Director of CAS, Mr. Guo Moruo was appointed the first president of USTC. USTC's founding mission was to develop a high-level science and technology workforce, as deemed critical for development of China's economy, defense, and science and technology education. The establishment was hailed as \\\"A Major Event in the History of Chinese Education and Science.\\\" CAS has supported USTC by combining most of its institutes with the departments of the university. USTC is listed in the top 16 national key universities, becoming the youngest national key university.\".lower()\n input_ids = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=511, return_tensors=\"pt\").input_ids\n\n input_ids = input_ids.to(torch_device)\n\n summary_ids = model.generate(\n input_ids, num_beams=4, length_penalty=1.0, no_repeat_ngram_size=3, early_stopping=True\n )\n EXPECTED_SUMMARIZE_512 = \"us ##tc was founded by the chinese academy of sciences ( cas ) in 1958 . [X_SEP] us ##tc is listed in the top 16 national key universities .\"\n generated_titles = [\n \" \".join(tokenizer.convert_ids_to_tokens(g, skip_special_tokens=True)) for g in summary_ids\n ]\n self.assertListEqual(\n [EXPECTED_SUMMARIZE_512],\n generated_titles,\n )\n input_ids = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=99, return_tensors=\"pt\").input_ids\n input_ids = input_ids.to(torch_device)\n # actually 98 tokens are used. max_length=100 contains bos and eos.\n summary_ids = model.generate(\n input_ids, num_beams=4, length_penalty=1.0, no_repeat_ngram_size=3, early_stopping=True\n )\n EXPECTED_SUMMARIZE_100 = (\n r\"us ##tc was founded in beijing by the chinese academy of sciences ( cas ) in 1958 . [X_SEP] us ##tc \"\n \"'\"\n ' s founding mission was to develop a high - level science and technology workforce . [X_SEP] establishment hailed as \" a major event in the history of chinese education and science \"'\n )\n generated_titles = [\n \" \".join(tokenizer.convert_ids_to_tokens(g, skip_special_tokens=True)) for g in summary_ids\n ]\n self.assertListEqual(\n [EXPECTED_SUMMARIZE_100],\n generated_titles,\n )\n\n @slow\n def test_question_gen_inference(self):\n model = ProphetNetForConditionalGeneration.from_pretrained(\"microsoft/prophetnet-large-uncased-squad-qg\")\n model.to(torch_device)\n\n tokenizer = ProphetNetTokenizer.from_pretrained(\"microsoft/prophetnet-large-uncased-squad-qg\")\n\n INPUTS = [\n \"Bill Gates [SEP] Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975.\",\n \"1975 [SEP] Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975.\",\n \"April 4, 1975 [SEP] Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975.\",\n ]\n\n input_ids = tokenizer(INPUTS, truncation=True, padding=True, return_tensors=\"pt\").input_ids\n input_ids = input_ids.to(torch_device)\n\n gen_output = model.generate(input_ids, num_beams=5, early_stopping=True)\n generated_questions = tokenizer.batch_decode(gen_output, skip_special_tokens=True)\n\n EXPECTED_QUESTIONS = [\n \"along with paul allen, who founded microsoft?\",\n \"what year was microsoft founded?\",\n \"on what date was microsoft founded?\",\n ]\n\n self.assertListEqual(\n EXPECTED_QUESTIONS,\n generated_questions,\n )\n"
] | [
[
"torch.ones_like",
"torch.ones",
"torch.Size",
"torch.manual_seed",
"torch.no_grad",
"torch.tensor",
"torch.all",
"torch.isnan",
"torch.cat",
"torch.allclose"
]
] |
adityasaxena26/OpenAI-Gym-Taxi-v2-Task | [
"e6061b39134c511de47b490f034317466c3c892e"
] | [
"agent.py"
] | [
"import numpy as np\nfrom collections import defaultdict\n\nclass Agent:\n\n def __init__(self, nA=6):\n \"\"\"\n Initialize agent.\n\n Params\n ======\n nA: number of actions available to the agent\n \"\"\"\n self.nA = nA\n self.Q = defaultdict(lambda: np.zeros(self.nA))\n\n def select_action(self, state):\n \"\"\"\n Given the state, select an action.\n\n Params\n ======\n state: the current state of the environment\n\n Returns\n =======\n action: an integer, compatible with the task's action space\n \"\"\"\n return np.random.choice(self.nA)\n\n def step(self, state, action, reward, next_state, done):\n \"\"\"\n Update the agent's knowledge, using the most recently sampled tuple.\n\n Params\n ======\n state: the previous state of the environment\n action: the agent's previous choice of action\n reward: last reward received\n next_state: the current state of the environment\n done: whether the episode is complete (True or False)\n \"\"\"\n self.Q[state][action] += 1\n"
] | [
[
"numpy.random.choice",
"numpy.zeros"
]
] |
astrobeard/VICEdev | [
"c78804ec63b48a760ce3e50b8d3afc7b699ec75f"
] | [
"starbursts/plots/mpl.SFEoscil.py"
] | [
"\nimport visuals \nimport matplotlib.pyplot as plt \nfrom matplotlib.ticker import FormatStrFormatter \nimport vice \nimport sys \nimport warnings \nwarnings.filterwarnings(\"ignore\") \n\nif __name__ == \"__main__\": \n\taxes = visuals.subplots(1, 3, figsize = (21, 7)) \n\taxes.insert(1, visuals.append_subplot_below(axes[0])) \n\taxes[0].xaxis.set_ticks([0, 2, 4, 6, 8, 10]) \n\taxes[0].set_xlim([-1, 11]) \n\taxes[0].set_ylim([2.1, 3.6]) \n\taxes[1].set_ylim([1.3, 2.7]) \n\taxes[2].set_xlim([-1.7, 0.2]) \n\taxes[2].set_ylim([-0.1, 0.5]) \n\taxes[3].set_xlim([-0.1, 0.5]) \n\taxes[3].set_ylim([0.2, 50]) \n\tvisuals.set_labels_4axes(axes, \"O\") \n\tinset_xlim = [-0.26, -0.06] \n\tinset_ylim = [0.06, 0.16]\n\tvisuals.draw_box(axes[2], inset_xlim, inset_ylim) \n\tinset = visuals.zoom_box(axes[2], inset_xlim, inset_ylim, zoom = 3.8) \n\tvisuals.plot_output_4axes(axes, \n\t\t\"../../simulations/SFEoscil_amp0p2_per4\", \"crimson\", \"O\") \n\tvisuals.plot_output_4axes(axes, \n\t\t\"../../simulations/SFEoscil_amp0p4_per2\", \"blue\", \"O\") \n\tvisuals.plot_output_4axes(axes, \n\t\t\"../../simulations/SFEoscil_amp0p2_per2\", \"black\", \"O\") \n\tvisuals.plot_inset(inset, \n\t\t\"../../simulations/SFEoscil_amp0p2_per4\", \"crimson\") \n\tvisuals.plot_inset(inset, \n\t\t\"../../simulations/SFEoscil_amp0p4_per2\", \"blue\") \n\tvisuals.plot_inset(inset, \n\t\t\"../../simulations/SFEoscil_amp0p2_per2\", \"black\") \n\tvisuals.plot_inset(inset, \n\t\t\"../../simulations/default\", \"black\", linestyle = ':') \n\tvisuals.plot_reference(axes) \n\tvisuals.yticklabel_formatter(axes[-1])\n\tplt.tight_layout() \n\tplt.savefig(sys.argv[1]) \n\tplt.clf() \n\n"
] | [
[
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.clf"
]
] |
ryanirl/ml-basics | [
"e143eacf6338877d8111d1c0ee56853475efa914"
] | [
"logistic_regression/logistic_regression.py"
] | [
"import numpy as np\nfrom sklearn.datasets import make_blobs\nimport matplotlib.pyplot as plt\n\n\n### --- Gather Dataset --- ###\n\nn = 100\nX, y = make_blobs(n_samples = n, centers = 2)\n\ny = y[:, np.newaxis]\n\n\n### --- Build Model --- ###\n\ndef sigmoid(z): \n return 1.0 / (1.0 + np.exp(-z))\n\nclass LogisticRegression:\n def predict(self, X, w, b):\n return sigmoid(X.dot(w) + b)\n\n def loss(self, pred, y):\n BCE = (y * np.log(pred + 1e-6) + (1 - y) * np.log(1 - pred + 1e-6)) \n return -np.sum(BCE) * (1.0 / self.m)\n\n def fit(self, X, y):\n eta = 0.01\n epochs = 5000\n\n self.m, self.n = X.shape\n\n self.weights = np.random.uniform(-1, 1, (self.n, 1))\n self.bias = np.random.uniform(-1, 1, (1, 1))\n\n for i in range(epochs):\n predicted = self.predict(X, self.weights, self.bias)\n\n if i % 100 == 0: print(\"Loss on step {} is: {}\".format(i, self.loss(predicted, y)))\n\n self.weights = self.weights - eta * X.T.dot(predicted - y)\n self.bias = self.bias - eta * np.sum(predicted - y)\n\n\n\n### --- Instantiate Model --- ###\n\nmodel = LogisticRegression()\nmodel.fit(X, y)\n\nweight0, weight1 = model.weights\nbias = model.bias[0][0]\n\n\n### --- Plot --- ###\n\nfor i in range(n):\n if (y[i] == 1):\n plt.scatter(X[:, 0][i], X[:, 1][i], color=\"green\") \n else:\n plt.scatter(X[:, 0][i], X[:, 1][i], color=\"blue\")\n\n \nx = np.linspace(-5, 5, 5)\n\nhyperplane = (-(weight0 / weight1) * x) - (bias / weight1)\n\nplt.suptitle(\"Logistic Regression\")\n\nplt.plot(x, hyperplane, '-', color = \"red\")\n\nplt.show()\n\n"
] | [
[
"numpy.random.uniform",
"numpy.sum",
"numpy.exp",
"matplotlib.pyplot.show",
"numpy.log",
"matplotlib.pyplot.suptitle",
"sklearn.datasets.make_blobs",
"matplotlib.pyplot.plot",
"numpy.linspace",
"matplotlib.pyplot.scatter"
]
] |
colliner/spektral | [
"b776200fd1fa820f05b559f0c1c6265e0eca4894"
] | [
"spektral/layers/convolutional/gat_conv.py"
] | [
"import tensorflow as tf\nfrom tensorflow.keras import backend as K\nfrom tensorflow.keras import initializers, regularizers, constraints\nfrom tensorflow.keras.layers import Dropout\n\nfrom spektral.layers import ops\nfrom spektral.layers.convolutional.conv import Conv\nfrom spektral.layers.ops import modes\n\n\nclass GATConv(Conv):\n r\"\"\"\n A Graph Attention layer (GAT) from the paper\n\n > [Graph Attention Networks](https://arxiv.org/abs/1710.10903)<br>\n > Petar Veličković et al.\n\n **Mode**: single, disjoint, mixed, batch.\n\n **This layer expects dense inputs when working in batch mode.**\n\n This layer computes a convolution similar to `layers.GraphConv`, but\n uses the attention mechanism to weight the adjacency matrix instead of\n using the normalized Laplacian:\n $$\n \\X' = \\mathbf{\\alpha}\\X\\W + \\b\n $$\n where\n $$\n \\mathbf{\\alpha}_{ij} =\\frac{ \\exp\\left(\\mathrm{LeakyReLU}\\left(\n \\a^{\\top} [(\\X\\W)_i \\, \\| \\, (\\X\\W)_j]\\right)\\right)}{\\sum\\limits_{k\n \\in \\mathcal{N}(i) \\cup \\{ i \\}} \\exp\\left(\\mathrm{LeakyReLU}\\left(\n \\a^{\\top} [(\\X\\W)_i \\, \\| \\, (\\X\\W)_k]\\right)\\right)}\n $$\n where \\(\\a \\in \\mathbb{R}^{2F'}\\) is a trainable attention kernel.\n Dropout is also applied to \\(\\alpha\\) before computing \\(\\Z\\).\n Parallel attention heads are computed in parallel and their results are\n aggregated by concatenation or average.\n\n **Input**\n\n - Node features of shape `([batch], n_nodes, n_node_features)`;\n - Binary adjacency matrix of shape `([batch], n_nodes, n_nodes)`;\n\n **Output**\n\n - Node features with the same shape as the input, but with the last\n dimension changed to `channels`;\n - if `return_attn_coef=True`, a list with the attention coefficients for\n each attention head. Each attention coefficient matrix has shape\n `([batch], n_nodes, n_nodes)`.\n\n **Arguments**\n\n - `channels`: number of output channels;\n - `attn_heads`: number of attention heads to use;\n - `concat_heads`: bool, whether to concatenate the output of the attention\n heads instead of averaging;\n - `dropout_rate`: internal dropout rate for attention coefficients;\n - `return_attn_coef`: if True, return the attention coefficients for\n the given input (one n_nodes x n_nodes matrix for each head).\n - `activation`: activation function;\n - `use_bias`: bool, add a bias vector to the output;\n - `kernel_initializer`: initializer for the weights;\n - `attn_kernel_initializer`: initializer for the attention weights;\n - `bias_initializer`: initializer for the bias vector;\n - `kernel_regularizer`: regularization applied to the weights;\n - `attn_kernel_regularizer`: regularization applied to the attention kernels;\n - `bias_regularizer`: regularization applied to the bias vector;\n - `activity_regularizer`: regularization applied to the output;\n - `kernel_constraint`: constraint applied to the weights;\n - `attn_kernel_constraint`: constraint applied to the attention kernels;\n - `bias_constraint`: constraint applied to the bias vector.\n\n \"\"\"\n\n def __init__(self,\n channels,\n attn_heads=1,\n concat_heads=True,\n dropout_rate=0.5,\n return_attn_coef=False,\n activation=None,\n use_bias=True,\n kernel_initializer='glorot_uniform',\n bias_initializer='zeros',\n attn_kernel_initializer='glorot_uniform',\n kernel_regularizer=None,\n bias_regularizer=None,\n attn_kernel_regularizer=None,\n activity_regularizer=None,\n kernel_constraint=None,\n bias_constraint=None,\n attn_kernel_constraint=None,\n **kwargs):\n super().__init__(activation=activation,\n use_bias=use_bias,\n kernel_initializer=kernel_initializer,\n bias_initializer=bias_initializer,\n kernel_regularizer=kernel_regularizer,\n bias_regularizer=bias_regularizer,\n activity_regularizer=activity_regularizer,\n kernel_constraint=kernel_constraint,\n bias_constraint=bias_constraint,\n **kwargs)\n self.channels = channels\n self.attn_heads = attn_heads\n self.concat_heads = concat_heads\n self.dropout_rate = dropout_rate\n self.return_attn_coef = return_attn_coef\n self.attn_kernel_initializer = initializers.get(attn_kernel_initializer)\n self.attn_kernel_regularizer = regularizers.get(attn_kernel_regularizer)\n self.attn_kernel_constraint = constraints.get(attn_kernel_constraint)\n\n if concat_heads:\n self.output_dim = self.channels * self.attn_heads\n else:\n self.output_dim = self.channels\n\n def build(self, input_shape):\n assert len(input_shape) >= 2\n input_dim = input_shape[0][-1]\n\n self.kernel = self.add_weight(\n name='kernel',\n shape=[input_dim, self.attn_heads, self.channels],\n initializer=self.kernel_initializer,\n regularizer=self.kernel_regularizer,\n constraint=self.kernel_constraint,\n )\n self.attn_kernel_self = self.add_weight(\n name='attn_kernel_self',\n shape=[self.channels, self.attn_heads, 1],\n initializer=self.attn_kernel_initializer,\n regularizer=self.attn_kernel_regularizer,\n constraint=self.attn_kernel_constraint,\n )\n self.attn_kernel_neighs = self.add_weight(\n name='attn_kernel_neigh',\n shape=[self.channels, self.attn_heads, 1],\n initializer=self.attn_kernel_initializer,\n regularizer=self.attn_kernel_regularizer,\n constraint=self.attn_kernel_constraint,\n )\n if self.use_bias:\n self.bias = self.add_weight(\n shape=[self.output_dim],\n initializer=self.bias_initializer,\n regularizer=self.bias_regularizer,\n constraint=self.bias_constraint,\n name='bias'\n )\n\n self.dropout = Dropout(self.dropout_rate)\n self.built = True\n\n def call(self, inputs):\n x, a = inputs\n\n mode = ops.autodetect_mode(a, x)\n if mode == modes.SINGLE and K.is_sparse(a):\n output, attn_coef = self._call_single(x, a)\n else:\n output, attn_coef = self._call_dense(x, a)\n\n if self.concat_heads:\n shape = output.shape[:-2] + [self.attn_heads * self.channels]\n shape = [d if d is not None else -1 for d in shape]\n output = tf.reshape(output, shape)\n else:\n output = tf.reduce_mean(output, axis=-2)\n\n if self.use_bias:\n output += self.bias\n\n output = self.activation(output)\n\n if self.return_attn_coef:\n return output, attn_coef\n else:\n return output\n\n def _call_single(self, x, a):\n # Reshape kernels for efficient message-passing\n kernel = tf.reshape(self.kernel, (-1, self.attn_heads * self.channels))\n attn_kernel_self = ops.transpose(self.attn_kernel_self, (2, 1, 0))\n attn_kernel_neighs = ops.transpose(self.attn_kernel_neighs, (2, 1, 0))\n\n # Prepare message-passing\n indices = a.indices\n N = tf.shape(x, out_type=indices.dtype)[0]\n indices = ops.add_self_loops_indices(indices, N)\n targets, sources = indices[:, -2], indices[:, -1]\n\n # Update node features\n x = ops.dot(x, kernel)\n x = tf.reshape(x, (-1, self.attn_heads, self.channels))\n\n # Compute attention\n attn_for_self = tf.reduce_sum(x * attn_kernel_self, -1)\n attn_for_self = tf.gather(attn_for_self, targets)\n attn_for_neighs = tf.reduce_sum(x * attn_kernel_neighs, -1)\n attn_for_neighs = tf.gather(attn_for_neighs, sources)\n\n attn_coef = attn_for_self + attn_for_neighs\n attn_coef = tf.nn.leaky_relu(attn_coef, alpha=0.2)\n attn_coef = ops.unsorted_segment_softmax(attn_coef, targets, N)\n attn_coef = self.dropout(attn_coef)\n attn_coef = attn_coef[..., None]\n\n # Update representation\n output = attn_coef * tf.gather(x, sources)\n output = ops.scatter_sum(output, targets, N)\n\n return output, attn_coef\n\n def _call_dense(self, x, a):\n shape = tf.shape(a)[:-1]\n a = tf.linalg.set_diag(a, tf.zeros(shape, a.dtype))\n a = tf.linalg.set_diag(a, tf.ones(shape, a.dtype))\n x = tf.einsum(\"...NI , IHO -> ...NHO\", x, self.kernel)\n attn_for_self = tf.einsum(\"...NHI , IHO -> ...NHO\", x, self.attn_kernel_self)\n attn_for_neighs = tf.einsum(\"...NHI , IHO -> ...NHO\", x, self.attn_kernel_neighs)\n attn_for_neighs = tf.einsum(\"...ABC -> ...CBA\", attn_for_neighs)\n\n attn_coef = attn_for_self + attn_for_neighs\n attn_coef = tf.nn.leaky_relu(attn_coef, alpha=0.2)\n\n mask = -10e9 * (1.0 - a)\n attn_coef += mask[..., None, :]\n attn_coef = tf.nn.softmax(attn_coef, axis=-1)\n attn_coef_drop = self.dropout(attn_coef)\n\n output = tf.einsum(\"...NHM , ...MHI -> ...NHI\", attn_coef_drop, x)\n\n return output, attn_coef\n\n @property\n def config(self):\n return {\n 'channels': self.channels,\n 'attn_heads': self.attn_heads,\n 'concat_heads': self.concat_heads,\n 'dropout_rate': self.dropout_rate,\n 'return_attn_coef': self.return_attn_coef,\n 'attn_kernel_initializer': initializers.serialize(self.attn_kernel_initializer),\n 'attn_kernel_regularizer': regularizers.serialize(self.attn_kernel_regularizer),\n 'attn_kernel_constraint': constraints.serialize(self.attn_kernel_constraint),\n }\n"
] | [
[
"tensorflow.zeros",
"tensorflow.keras.initializers.get",
"tensorflow.keras.layers.Dropout",
"tensorflow.shape",
"tensorflow.reshape",
"tensorflow.keras.backend.is_sparse",
"tensorflow.keras.constraints.get",
"tensorflow.ones",
"tensorflow.nn.softmax",
"tensorflow.reduce_mean",
"tensorflow.keras.constraints.serialize",
"tensorflow.nn.leaky_relu",
"tensorflow.keras.regularizers.serialize",
"tensorflow.einsum",
"tensorflow.keras.initializers.serialize",
"tensorflow.gather",
"tensorflow.keras.regularizers.get",
"tensorflow.reduce_sum"
]
] |
Abrahamma97/keras-onnx | [
"c08d52bf4d4ec2bba69ec4ffd2ea14f47fecb1f5",
"e49ef6163e1f2be017fff96f908eaea819f6e0b4"
] | [
"applications/nightly_build/test_lsgan.py",
"tests/test_cgan.py"
] | [
"###############################################################################\n# Copyright (c) Microsoft Corporation. All rights reserved.\n# Licensed under the MIT License. See License.txt in the project root for\n# license information.\n###############################################################################\nimport os\nimport sys\nimport unittest\nimport keras2onnx\nimport onnx\nimport numpy as np\nfrom keras2onnx.proto import keras\nfrom os.path import dirname, abspath\nsys.path.insert(0, os.path.join(dirname(abspath(__file__)), '../../tests/'))\nfrom test_utils import run_onnx_runtime\n\nActivation = keras.layers.Activation\nBatchNormalization = keras.layers.BatchNormalization\nConv2D = keras.layers.Conv2D\nDense = keras.layers.Dense\nDropout = keras.layers.Dropout\nEmbedding = keras.layers.Embedding\nFlatten = keras.layers.Flatten\nInput = keras.layers.Input\nLeakyReLU = keras.layers.LeakyReLU\nmultiply = keras.layers.multiply\nReshape = keras.layers.Reshape\nUpSampling2D = keras.layers.UpSampling2D\nZeroPadding2D = keras.layers.ZeroPadding2D\n\nSequential = keras.models.Sequential\nModel = keras.models.Model\n\n# From https://github.com/eriklindernoren/Keras-GAN/blob/master/lsgan/lsgan.py\nclass LSGAN():\n def __init__(self):\n self.img_rows = 28\n self.img_cols = 28\n self.channels = 1\n self.img_shape = (self.img_rows, self.img_cols, self.channels)\n self.latent_dim = 100\n\n # Build and compile the discriminator\n self.discriminator = self.build_discriminator()\n\n # Build the generator\n self.generator = self.build_generator()\n\n # The generator takes noise as input and generated imgs\n z = Input(shape=(self.latent_dim,))\n img = self.generator(z)\n\n # For the combined model we will only train the generator\n self.discriminator.trainable = False\n\n # The valid takes generated images as input and determines validity\n valid = self.discriminator(img)\n\n # The combined model (stacked generator and discriminator)\n # Trains generator to fool discriminator\n self.combined = Model(z, valid)\n\n def build_generator(self):\n\n model = Sequential()\n\n model.add(Dense(256, input_dim=self.latent_dim))\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n model.add(Dense(512))\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n model.add(Dense(1024))\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n model.add(Dense(np.prod(self.img_shape), activation='tanh'))\n model.add(Reshape(self.img_shape))\n\n noise = Input(shape=(self.latent_dim,))\n img = model(noise)\n\n return Model(noise, img)\n\n def build_discriminator(self):\n\n model = Sequential()\n\n model.add(Flatten(input_shape=self.img_shape))\n model.add(Dense(512))\n model.add(LeakyReLU(alpha=0.2))\n model.add(Dense(256))\n model.add(LeakyReLU(alpha=0.2))\n # (!!!) No softmax\n model.add(Dense(1))\n\n img = Input(shape=self.img_shape)\n validity = model(img)\n\n return Model(img, validity)\n\n\nclass TestLSGAN(unittest.TestCase):\n\n def setUp(self):\n self.model_files = []\n\n def tearDown(self):\n for fl in self.model_files:\n os.remove(fl)\n\n def test_LSGAN(self):\n keras_model = LSGAN().combined\n x = np.random.rand(5, 100).astype(np.float32)\n expected = keras_model.predict(x)\n onnx_model = keras2onnx.convert_keras(keras_model, keras_model.name)\n self.assertTrue(run_onnx_runtime(onnx_model.graph.name, onnx_model, x, expected, self.model_files))\n\n\nif __name__ == \"__main__\":\n unittest.main()\n",
"###############################################################################\n# Copyright (c) Microsoft Corporation. All rights reserved.\n# Licensed under the MIT License. See License.txt in the project root for\n# license information.\n###############################################################################\nimport pytest\nimport tensorflow as tf\nimport keras2onnx\nimport numpy as np\nfrom keras2onnx.proto import keras, is_tf_keras\nfrom distutils.version import StrictVersion\n\nActivation = keras.layers.Activation\nBatchNormalization = keras.layers.BatchNormalization\nDense = keras.layers.Dense\nDropout = keras.layers.Dropout\nEmbedding = keras.layers.Embedding\nFlatten = keras.layers.Flatten\nInput = keras.layers.Input\nLeakyReLU = keras.layers.LeakyReLU\nmultiply = keras.layers.multiply\nReshape = keras.layers.Reshape\nUpSampling2D = keras.layers.UpSampling2D\n\nSequential = keras.models.Sequential\nModel = keras.models.Model\n\n\n# From https://github.com/eriklindernoren/Keras-GAN/blob/master/cgan/cgan.py\nclass CGAN():\n def __init__(self):\n # Input shape\n self.img_rows = 28\n self.img_cols = 28\n self.channels = 1\n self.img_shape = (self.img_rows, self.img_cols, self.channels)\n self.num_classes = 10\n self.latent_dim = 100\n\n # Build and compile the discriminator\n self.discriminator = self.build_discriminator()\n\n # Build the generator\n self.generator = self.build_generator()\n\n # The generator takes noise and the target label as input\n # and generates the corresponding digit of that label\n noise = Input(shape=(self.latent_dim,))\n label = Input(shape=(1,))\n img = self.generator([noise, label])\n\n # For the combined model we will only train the generator\n self.discriminator.trainable = False\n\n # The discriminator takes generated image as input and determines validity\n # and the label of that image\n valid = self.discriminator([img, label])\n\n # The combined model (stacked generator and discriminator)\n # Trains generator to fool discriminator\n self.combined = Model([noise, label], valid)\n\n def get_model(self):\n return self.combined\n\n def build_generator(self):\n model = Sequential()\n\n model.add(Dense(256, input_dim=self.latent_dim))\n\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n model.add(Dense(512))\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n model.add(Dense(1024))\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n\n model.add(Dense(np.prod(self.img_shape), activation='tanh'))\n model.add(Reshape(self.img_shape))\n\n noise = Input(shape=(self.latent_dim,))\n label = Input(shape=(1,), dtype='int32')\n label_embedding = Flatten()(Embedding(self.num_classes, self.latent_dim)(label))\n\n model_input = multiply([noise, label_embedding])\n img = model(model_input)\n\n return Model([noise, label], img)\n\n def build_discriminator(self):\n model = Sequential()\n\n model.add(Dense(512, input_dim=np.prod(self.img_shape)))\n model.add(LeakyReLU(alpha=0.2))\n model.add(Dense(512))\n model.add(LeakyReLU(alpha=0.2))\n model.add(Dropout(0.4))\n model.add(Dense(512))\n model.add(LeakyReLU(alpha=0.2))\n model.add(Dropout(0.4))\n model.add(Dense(1, activation='sigmoid'))\n\n model.add(Dense(1, activation='sigmoid'))\n\n img = Input(shape=self.img_shape)\n label = Input(shape=(1,), dtype='int32')\n\n label_embedding = Flatten()(Embedding(self.num_classes, np.prod(self.img_shape))(label))\n flat_img = Flatten()(img)\n\n model_input = multiply([flat_img, label_embedding])\n\n validity = model(model_input)\n\n return Model([img, label], validity)\n\n\[email protected](keras2onnx.proto.tfcompat.is_tf2 and is_tf_keras, reason=\"Tensorflow 1.x only tests.\")\[email protected](is_tf_keras and StrictVersion(tf.__version__.split('-')[0]) < StrictVersion(\"1.14.0\"),\n reason=\"Not supported before tensorflow 1.14.0 for tf_keras\")\ndef test_CGAN(runner):\n keras_model = CGAN().combined\n batch = 5\n x = np.random.rand(batch, 100).astype(np.float32)\n y = np.random.rand(batch, 1).astype(np.float32)\n expected = keras_model.predict([x, y])\n onnx_model = keras2onnx.convert_keras(keras_model, keras_model.name)\n assert runner(onnx_model.graph.name, onnx_model,\n {keras_model.input_names[0]: x, keras_model.input_names[1]: y}, expected)\n"
] | [
[
"numpy.random.rand",
"numpy.prod"
],
[
"numpy.random.rand",
"tensorflow.__version__.split",
"numpy.prod"
]
] |
Izecson/sockeye-1.16.6 | [
"f84044d4a64b2bcf744ccd4f94b16f8133d1f383"
] | [
"test/unit/test_attention.py"
] | [
"# Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"). You may not\n# use this file except in compliance with the License. A copy of the License\n# is located at\n#\n# http://aws.amazon.com/apache2.0/\n# \n# or in the \"license\" file accompanying this file. This file is distributed on\n# an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n# express or implied. See the License for the specific language governing\n# permissions and limitations under the License.\n\nimport mxnet as mx\nimport numpy as np\nimport pytest\n\nimport sockeye.constants as C\nimport sockeye.coverage\nimport sockeye.rnn_attention\nfrom test.common import gaussian_vector, integer_vector\n\nattention_types = [C.ATT_BILINEAR, C.ATT_DOT, C.ATT_DOT_SCALED, C.ATT_LOC, C.ATT_MLP]\n\n\[email protected](\"attention_type\", attention_types)\ndef test_attention(attention_type,\n batch_size=1,\n encoder_num_hidden=2,\n decoder_num_hidden=2):\n # source: (batch_size, seq_len, encoder_num_hidden)\n source = mx.sym.Variable(\"source\")\n # source_length: (batch_size,)\n source_length = mx.sym.Variable(\"source_length\")\n source_seq_len = 3\n\n config_attention = sockeye.rnn_attention.AttentionConfig(type=attention_type,\n num_hidden=2,\n input_previous_word=False,\n source_num_hidden=2,\n query_num_hidden=2,\n layer_normalization=False,\n config_coverage=None)\n attention = sockeye.rnn_attention.get_attention(config_attention, max_seq_len=source_seq_len)\n\n attention_state = attention.get_initial_state(source_length, source_seq_len)\n attention_func = attention.on(source, source_length, source_seq_len)\n attention_input = attention.make_input(0, mx.sym.Variable(\"word_vec_prev\"), mx.sym.Variable(\"decoder_state\"))\n attention_state = attention_func(attention_input, attention_state)\n sym = mx.sym.Group([attention_state.context, attention_state.probs])\n\n executor = sym.simple_bind(ctx=mx.cpu(),\n source=(batch_size, source_seq_len, encoder_num_hidden),\n source_length=(batch_size,),\n decoder_state=(batch_size, decoder_num_hidden))\n\n # TODO: test for other inputs (that are not equal at each source position)\n executor.arg_dict[\"source\"][:] = np.asarray([[[1., 2.], [1., 2.], [3., 4.]]])\n executor.arg_dict[\"source_length\"][:] = np.asarray([2.0])\n executor.arg_dict[\"decoder_state\"][:] = np.asarray([[5, 6]])\n exec_output = executor.forward()\n context_result = exec_output[0].asnumpy()\n attention_prob_result = exec_output[1].asnumpy()\n\n # expecting uniform attention_weights of 0.5: 0.5 * seq1 + 0.5 * seq2\n assert np.isclose(context_result, np.asarray([[1., 2.]])).all()\n # equal attention to first two and no attention to third\n assert np.isclose(attention_prob_result, np.asarray([[0.5, 0.5, 0.]])).all()\n\n\ncoverage_cases = [(\"gru\", 10), (\"tanh\", 4), (\"count\", 1), (\"sigmoid\", 1), (\"relu\", 30)]\n\n\[email protected](\"attention_coverage_type,attention_coverage_num_hidden\", coverage_cases)\ndef test_coverage_attention(attention_coverage_type,\n attention_coverage_num_hidden,\n batch_size=3,\n encoder_num_hidden=2,\n decoder_num_hidden=2):\n # source: (batch_size, seq_len, encoder_num_hidden)\n source = mx.sym.Variable(\"source\")\n # source_length: (batch_size, )\n source_length = mx.sym.Variable(\"source_length\")\n source_seq_len = 10\n\n config_coverage = sockeye.coverage.CoverageConfig(type=attention_coverage_type,\n num_hidden=attention_coverage_num_hidden,\n layer_normalization=False)\n config_attention = sockeye.rnn_attention.AttentionConfig(type=\"coverage\",\n num_hidden=5,\n input_previous_word=False,\n source_num_hidden=encoder_num_hidden,\n query_num_hidden=decoder_num_hidden,\n layer_normalization=False,\n config_coverage=config_coverage)\n attention = sockeye.rnn_attention.get_attention(config_attention, max_seq_len=source_seq_len)\n\n attention_state = attention.get_initial_state(source_length, source_seq_len)\n attention_func = attention.on(source, source_length, source_seq_len)\n attention_input = attention.make_input(0, mx.sym.Variable(\"word_vec_prev\"), mx.sym.Variable(\"decoder_state\"))\n attention_state = attention_func(attention_input, attention_state)\n sym = mx.sym.Group([attention_state.context, attention_state.probs, attention_state.dynamic_source])\n\n source_shape = (batch_size, source_seq_len, encoder_num_hidden)\n source_length_shape = (batch_size,)\n decoder_state_shape = (batch_size, decoder_num_hidden)\n\n executor = sym.simple_bind(ctx=mx.cpu(),\n source=source_shape,\n source_length=source_length_shape,\n decoder_state=decoder_state_shape)\n\n source_length_vector = integer_vector(shape=source_length_shape, max_value=source_seq_len)\n executor.arg_dict[\"source\"][:] = gaussian_vector(shape=source_shape)\n executor.arg_dict[\"source_length\"][:] = source_length_vector\n executor.arg_dict[\"decoder_state\"][:] = gaussian_vector(shape=decoder_state_shape)\n exec_output = executor.forward()\n context_result = exec_output[0].asnumpy()\n attention_prob_result = exec_output[1].asnumpy()\n dynamic_source_result = exec_output[2].asnumpy()\n\n expected_probs = (1. / source_length_vector).reshape((batch_size, 1))\n\n assert context_result.shape == (batch_size, encoder_num_hidden)\n assert attention_prob_result.shape == (batch_size, source_seq_len)\n assert dynamic_source_result.shape == (batch_size, source_seq_len, attention_coverage_num_hidden)\n assert (np.sum(np.isclose(attention_prob_result, expected_probs), axis=1) == source_length_vector).all()\n\n\ndef test_last_state_attention(batch_size=1,\n encoder_num_hidden=2):\n \"\"\"\n EncoderLastStateAttention is a bit different from other attention mechanisms as it doesn't take a query argument\n and doesn't return a probability distribution over the inputs (aka alignment).\n \"\"\"\n # source: (batch_size, seq_len, encoder_num_hidden)\n source = mx.sym.Variable(\"source\")\n # source_length: (batch_size,)\n source_length = mx.sym.Variable(\"source_length\")\n source_seq_len = 3\n\n config_attention = sockeye.rnn_attention.AttentionConfig(type=\"fixed\",\n num_hidden=0,\n input_previous_word=False,\n source_num_hidden=2,\n query_num_hidden=2,\n layer_normalization=False,\n config_coverage=None)\n attention = sockeye.rnn_attention.get_attention(config_attention, max_seq_len=source_seq_len)\n\n attention_state = attention.get_initial_state(source_length, source_seq_len)\n attention_func = attention.on(source, source_length, source_seq_len)\n attention_input = attention.make_input(0, mx.sym.Variable(\"word_vec_prev\"), mx.sym.Variable(\"decoder_state\"))\n attention_state = attention_func(attention_input, attention_state)\n sym = mx.sym.Group([attention_state.context, attention_state.probs])\n\n executor = sym.simple_bind(ctx=mx.cpu(),\n source=(batch_size, source_seq_len, encoder_num_hidden),\n source_length=(batch_size,))\n\n # TODO: test for other inputs (that are not equal at each source position)\n executor.arg_dict[\"source\"][:] = np.asarray([[[1., 2.], [1., 2.], [3., 4.]]])\n executor.arg_dict[\"source_length\"][:] = np.asarray([2.0])\n exec_output = executor.forward()\n context_result = exec_output[0].asnumpy()\n attention_prob_result = exec_output[1].asnumpy()\n\n # expecting attention on last state based on source_length\n assert np.isclose(context_result, np.asarray([[1., 2.]])).all()\n assert np.isclose(attention_prob_result, np.asarray([[0., 1.0, 0.]])).all()\n\n\ndef test_get_context_and_attention_probs():\n source = mx.sym.Variable('source')\n source_length = mx.sym.Variable('source_length')\n attention_scores = mx.sym.Variable('scores')\n context, att_probs = sockeye.rnn_attention.get_context_and_attention_probs(source, source_length, attention_scores)\n sym = mx.sym.Group([context, att_probs])\n assert len(sym.list_arguments()) == 3\n\n batch_size, seq_len, num_hidden = 32, 50, 100\n\n # data\n source_nd = mx.nd.random_normal(shape=(batch_size, seq_len, num_hidden))\n source_length_np = np.random.randint(1, seq_len+1, (batch_size,))\n source_length_nd = mx.nd.array(source_length_np)\n scores_nd = mx.nd.zeros((batch_size, seq_len, 1))\n\n in_shapes, out_shapes, _ = sym.infer_shape(source=source_nd.shape,\n source_length=source_length_nd.shape,\n scores=scores_nd.shape)\n\n assert in_shapes == [(batch_size, seq_len, num_hidden), (batch_size, seq_len, 1), (batch_size,)]\n assert out_shapes == [(batch_size, num_hidden), (batch_size, seq_len)]\n\n context, probs = sym.eval(source=source_nd,\n source_length=source_length_nd,\n scores=scores_nd)\n\n expected_probs = (1. / source_length_nd).reshape((batch_size, 1)).asnumpy()\n assert (np.sum(np.isclose(probs.asnumpy(), expected_probs), axis=1) == source_length_np).all()\n"
] | [
[
"numpy.random.randint",
"numpy.isclose",
"numpy.asarray"
]
] |
yileiCao/shareTheBest | [
"ef62396a7884954dd6464d2dd78e232273e1060b"
] | [
"trilinear_cpp/setup.py"
] | [
"from setuptools import setup\nimport torch\nfrom torch.utils.cpp_extension import BuildExtension, CUDAExtension, CppExtension\n\nif torch.cuda.is_available():\n print('Including CUDA code.')\n setup(\n name='trilinear',\n ext_modules=[\n CUDAExtension('trilinear', [\n 'src/trilinear_cuda.cpp',\n 'src/trilinear_kernel.cu',\n ])\n ],\n cmdclass={\n 'build_ext': BuildExtension\n })\nelse:\n print('NO CUDA is found. Fall back to CPU.')\n setup(name='trilinear',\n ext_modules=[CppExtension('trilinear', ['src/trilinear.cpp'])],\n cmdclass={'build_ext': BuildExtension})\n"
] | [
[
"torch.utils.cpp_extension.CUDAExtension",
"torch.cuda.is_available",
"torch.utils.cpp_extension.CppExtension"
]
] |
jfajkowski/stock-market-forecasting | [
"6a0ae5a0cfe39263a0f448f062cd01283281a0d8"
] | [
"scripts/model/bigram_svm/train_model.py"
] | [
"import pandas as pd\nfrom sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.svm import SVC\n\n# %% Load data\ndf = pd.read_csv('./data/interim/Classes_Changed.csv')\n\nraw = df.loc[:, 'Top1':'Top25'].apply(lambda x: ' '.join([str(s) for s in x]), axis=1)\ny = df['Class']\n\n# %% Split it into test and training sets\nraw_train, raw_test, y_train, y_test = train_test_split(raw, y, train_size=0.8, shuffle=False)\n\n# %% Define model\nclf = SVC(decision_function_shape='ovo', kernel='rbf', probability=True)\nmodel = Pipeline([\n ('vect', CountVectorizer(ngram_range=(2, 2), stop_words='english')),\n ('tfidf', TfidfTransformer(use_idf=False)),\n ('scale', StandardScaler(with_mean=False)),\n ('clf', clf),\n])\nmodel.fit(raw_train, y_train)\naccuracy_score(y_test, model.predict(raw_test))\n\n# %% Persist it\nimport pickle\nwith open('./models/raw_bigram_svm.mdl', mode='wb') as model_file:\n pickle.dump(model, model_file)\n\n\n\n"
] | [
[
"sklearn.svm.SVC",
"sklearn.feature_extraction.text.CountVectorizer",
"pandas.read_csv",
"sklearn.feature_extraction.text.TfidfTransformer",
"sklearn.preprocessing.StandardScaler",
"sklearn.model_selection.train_test_split"
]
] |
wilson1yan/SLM-Lab | [
"1f110288d2d3dde1fb00d415aeb95ce554170813"
] | [
"slm_lab/agent/algorithm/dqn.py"
] | [
"from slm_lab.agent import net\nfrom slm_lab.agent.algorithm import policy_util\nfrom slm_lab.agent.algorithm.sarsa import SARSA\nfrom slm_lab.agent.net import net_util\nfrom slm_lab.lib import logger, util\nfrom slm_lab.lib.decorator import lab_api\nimport numpy as np\nimport pydash as ps\nimport torch\n\nlogger = logger.get_logger(__name__)\n\n\nclass VanillaDQN(SARSA):\n '''\n Implementation of a simple DQN algorithm.\n Algorithm:\n 1. Collect some examples by acting in the environment and store them in a replay memory\n 2. Every K steps sample N examples from replay memory\n 3. For each example calculate the target (bootstrapped estimate of the discounted value of the state and action taken), y, using a neural network to approximate the Q function. s' is the next state following the action actually taken.\n y_t = r_t + gamma * argmax_a Q(s_t', a)\n 4. For each example calculate the current estimate of the discounted value of the state and action taken\n x_t = Q(s_t, a_t)\n 5. Calculate L(x, y) where L is a regression loss (eg. mse)\n 6. Calculate the gradient of L with respect to all the parameters in the network and update the network parameters using the gradient\n 7. Repeat steps 3 - 6 M times\n 8. Repeat steps 2 - 7 Z times\n 9. Repeat steps 1 - 8\n\n For more information on Q-Learning see Sergey Levine's lectures 6 and 7 from CS294-112 Fall 2017\n https://www.youtube.com/playlist?list=PLkFD6_40KJIznC9CDbVTjAF2oyt8_VAe3\n\n e.g. algorithm_spec\n \"algorithm\": {\n \"name\": \"VanillaDQN\",\n \"action_pdtype\": \"Argmax\",\n \"action_policy\": \"epsilon_greedy\",\n \"explore_var_spec\": {\n \"name\": \"linear_decay\",\n \"start_val\": 1.0,\n \"end_val\": 0.1,\n \"start_step\": 10,\n \"end_step\": 1000,\n },\n \"gamma\": 0.99,\n \"training_batch_epoch\": 8,\n \"training_epoch\": 4,\n \"training_frequency\": 10,\n \"training_start_step\": 10,\n \"normalize_state\": true\n }\n '''\n\n @lab_api\n def init_algorithm_params(self):\n # set default\n util.set_attr(self, dict(\n action_pdtype='Argmax',\n action_policy='epsilon_greedy',\n explore_var_spec=None,\n ))\n util.set_attr(self, self.algorithm_spec, [\n 'action_pdtype',\n 'action_policy',\n # explore_var is epsilon, tau or etc. depending on the action policy\n # these control the trade off between exploration and exploitaton\n 'explore_var_spec',\n 'gamma', # the discount factor\n 'training_batch_epoch', # how many gradient updates per batch\n 'training_epoch', # how many batches to train each time\n 'training_frequency', # how often to train (once a few timesteps)\n 'training_start_step', # how long before starting training\n 'normalize_state',\n ])\n super(VanillaDQN, self).init_algorithm_params()\n\n @lab_api\n def init_nets(self, global_nets=None):\n '''Initialize the neural network used to learn the Q function from the spec'''\n if self.algorithm_spec['name'] == 'VanillaDQN':\n assert all(k not in self.net_spec for k in ['update_type', 'update_frequency', 'polyak_coef']), 'Network update not available for VanillaDQN; use DQN.'\n if global_nets is None:\n in_dim = self.body.state_dim\n out_dim = net_util.get_out_dim(self.body)\n NetClass = getattr(net, self.net_spec['type'])\n self.net = NetClass(self.net_spec, in_dim, out_dim)\n self.net_names = ['net']\n else:\n util.set_attr(self, global_nets)\n self.net_names = list(global_nets.keys())\n self.post_init_nets()\n\n def calc_q_loss(self, batch):\n '''Compute the Q value loss using predicted and target Q values from the appropriate networks'''\n q_preds = self.net.wrap_eval(batch['states'])\n # q_preds = self.net(batch['states'])\n act_q_preds = q_preds.gather(-1, batch['actions'].long().unsqueeze(-1)).squeeze(-1)\n next_q_preds = self.net.wrap_eval(batch['next_states'])\n # Bellman equation: compute max_q_targets using reward and max estimated Q values (0 if no next_state)\n max_next_q_preds, _ = next_q_preds.max(dim=-1, keepdim=True)\n max_q_targets = batch['rewards'] + self.gamma * (1 - batch['dones']) * max_next_q_preds\n max_q_targets = max_q_targets.detach()\n q_loss = self.net.loss_fn(act_q_preds, max_q_targets)\n\n # TODO use the same loss_fn but do not reduce yet\n if 'Prioritized' in util.get_class_name(self.body.memory): # PER\n errors = torch.abs(max_q_targets - act_q_preds.detach())\n self.body.memory.update_priorities(errors)\n\n return q_loss\n\n @lab_api\n def act(self, state):\n '''Selects and returns a discrete action for body using the action policy'''\n return super(VanillaDQN, self).act(state)\n\n @lab_api\n def sample(self):\n '''Samples a batch from memory of size self.memory_spec['batch_size']'''\n batch = self.body.memory.sample()\n if self.normalize_state:\n batch = policy_util.normalize_states_and_next_states(self.body, batch)\n batch = util.to_torch_batch(batch, self.net.device, self.body.memory.is_episodic)\n return batch\n\n @lab_api\n def train(self):\n '''\n Completes one training step for the agent if it is time to train.\n i.e. the environment timestep is greater than the minimum training timestep and a multiple of the training_frequency.\n Each training step consists of sampling n batches from the agent's memory.\n For each of the batches, the target Q values (q_targets) are computed and a single training step is taken k times\n Otherwise this function does nothing.\n '''\n if util.get_lab_mode() in ('enjoy', 'eval'):\n self.body.flush()\n return np.nan\n clock = self.body.env.clock\n tick = clock.get(clock.max_tick_unit)\n self.to_train = (tick > self.training_start_step and tick % self.training_frequency == 0)\n if self.to_train == 1:\n total_loss = torch.tensor(0.0, device=self.net.device)\n for _ in range(self.training_epoch):\n batch = self.sample()\n for _ in range(self.training_batch_epoch):\n loss = self.calc_q_loss(batch)\n self.net.training_step(loss=loss, lr_clock=clock)\n total_loss += loss\n loss = total_loss / (self.training_epoch * self.training_batch_epoch)\n # reset\n self.to_train = 0\n self.body.flush()\n logger.debug(f'Trained {self.name} at epi: {clock.epi}, total_t: {clock.total_t}, t: {clock.t}, total_reward so far: {self.body.memory.total_reward}, loss: {loss:.8f}')\n return loss.item()\n else:\n return np.nan\n\n @lab_api\n def update(self):\n '''Update the agent after training'''\n return super(VanillaDQN, self).update()\n\n\nclass DQNBase(VanillaDQN):\n '''\n Implementation of the base DQN algorithm.\n The algorithm follows the same general approach as VanillaDQN but is more general since it allows\n for two different networks (through self.net and self.target_net).\n\n self.net is used to act, and is the network trained.\n self.target_net is used to estimate the maximum value of the Q-function in the next state when calculating the target (see VanillaDQN comments).\n self.target_net is updated periodically to either match self.net (self.net.update_type = \"replace\") or to be a weighted average of self.net and the previous self.target_net (self.net.update_type = \"polyak\")\n If desired, self.target_net can be updated slowly, and this can help to stabilize learning.\n\n It also allows for different nets to be used to select the action in the next state and to evaluate the value of that action through self.online_net and self.eval_net. This can help reduce the tendency of DQN's to overestimate the value of the Q-function. Following this approach leads to the DoubleDQN algorithm.\n\n Setting all nets to self.net reduces to the VanillaDQN case.\n '''\n\n @lab_api\n def init_nets(self, global_nets=None):\n '''Initialize networks'''\n if self.algorithm_spec['name'] == 'DQNBase':\n assert all(k not in self.net_spec for k in ['update_type', 'update_frequency', 'polyak_coef']), 'Network update not available for DQNBase; use DQN.'\n if global_nets is None:\n in_dim = self.body.state_dim\n out_dim = net_util.get_out_dim(self.body)\n NetClass = getattr(net, self.net_spec['type'])\n self.net = NetClass(self.net_spec, in_dim, out_dim)\n self.target_net = NetClass(self.net_spec, in_dim, out_dim)\n self.net_names = ['net', 'target_net']\n else:\n util.set_attr(self, global_nets)\n self.net_names = list(global_nets.keys())\n self.post_init_nets()\n self.online_net = self.target_net\n self.eval_net = self.target_net\n\n def calc_q_loss(self, batch):\n '''Compute the Q value loss using predicted and target Q values from the appropriate networks'''\n q_preds = self.net(batch['states'])\n act_q_preds = q_preds.gather(-1, batch['actions'].long().unsqueeze(-1)).squeeze(-1)\n # Use online_net to select actions in next state\n online_next_q_preds = self.online_net.wrap_eval(batch['next_states'])\n # Use eval_net to calculate next_q_preds for actions chosen by online_net\n next_q_preds = self.eval_net.wrap_eval(batch['next_states'])\n max_next_q_preds = next_q_preds.gather(-1, online_next_q_preds.argmax(dim=-1, keepdim=True)).squeeze(-1)\n max_q_targets = batch['rewards'] + self.gamma * (1 - batch['dones']) * max_next_q_preds\n max_q_targets = max_q_targets.detach()\n q_loss = self.net.loss_fn(act_q_preds, max_q_targets)\n\n # TODO use the same loss_fn but do not reduce yet\n if 'Prioritized' in util.get_class_name(self.body.memory): # PER\n errors = torch.abs(max_q_targets - act_q_preds.detach())\n self.body.memory.update_priorities(errors)\n return q_loss\n\n def update_nets(self):\n total_t = self.body.env.clock.total_t\n if self.net.update_type == 'replace':\n if total_t % self.net.update_frequency == 0:\n logger.debug('Updating target_net by replacing')\n net_util.copy(self.net, self.target_net)\n self.online_net = self.target_net\n self.eval_net = self.target_net\n elif self.net.update_type == 'polyak':\n logger.debug('Updating net by averaging')\n net_util.polyak_update(self.net, self.target_net, self.net.polyak_coef)\n self.online_net = self.target_net\n self.eval_net = self.target_net\n else:\n raise ValueError('Unknown net.update_type. Should be \"replace\" or \"polyak\". Exiting.')\n\n @lab_api\n def update(self):\n '''Updates self.target_net and the explore variables'''\n self.update_nets()\n return super(DQNBase, self).update()\n\n\nclass DQN(DQNBase):\n '''\n DQN class\n\n e.g. algorithm_spec\n \"algorithm\": {\n \"name\": \"DQN\",\n \"action_pdtype\": \"Argmax\",\n \"action_policy\": \"epsilon_greedy\",\n \"explore_var_spec\": {\n \"name\": \"linear_decay\",\n \"start_val\": 1.0,\n \"end_val\": 0.1,\n \"start_step\": 10,\n \"end_step\": 1000,\n },\n \"gamma\": 0.99,\n \"training_batch_epoch\": 8,\n \"training_epoch\": 4,\n \"training_frequency\": 10,\n \"training_start_step\": 10\n }\n '''\n @lab_api\n def init_nets(self, global_nets=None):\n super(DQN, self).init_nets(global_nets)\n\n\nclass DoubleDQN(DQN):\n '''\n Double-DQN (DDQN) class\n\n e.g. algorithm_spec\n \"algorithm\": {\n \"name\": \"DDQN\",\n \"action_pdtype\": \"Argmax\",\n \"action_policy\": \"epsilon_greedy\",\n \"explore_var_spec\": {\n \"name\": \"linear_decay\",\n \"start_val\": 1.0,\n \"end_val\": 0.1,\n \"start_step\": 10,\n \"end_step\": 1000,\n },\n \"gamma\": 0.99,\n \"training_batch_epoch\": 8,\n \"training_epoch\": 4,\n \"training_frequency\": 10,\n \"training_start_step\": 10\n }\n '''\n @lab_api\n def init_nets(self, global_nets=None):\n super(DoubleDQN, self).init_nets(global_nets)\n self.online_net = self.net\n self.eval_net = self.target_net\n\n def update_nets(self):\n res = super(DoubleDQN, self).update_nets()\n total_t = self.body.env.clock.total_t\n if self.net.update_type == 'replace':\n if total_t % self.net.update_frequency == 0:\n self.online_net = self.net\n self.eval_net = self.target_net\n elif self.net.update_type == 'polyak':\n self.online_net = self.net\n self.eval_net = self.target_net\n"
] | [
[
"torch.tensor"
]
] |
Connossor/bokeh | [
"092e5dc0f62be13d87af5bf2b5a85ec57fd9f14e"
] | [
"examples/plotting/file/stocks.py"
] | [
"import numpy as np\n\nfrom bokeh.layouts import gridplot\nfrom bokeh.plotting import figure, show, output_file\nfrom bokeh.sampledata.stocks import AAPL, GOOG, IBM, MSFT\n\ndef datetime(x):\n return np.array(x, dtype=np.datetime64)\n\np1 = figure(x_axis_type=\"datetime\", title=\"Stock Closing Prices\")\np1.grid.grid_line_alpha=0.3\np1.xaxis.axis_label = 'Date'\np1.yaxis.axis_label = 'Price'\n\np1.line(datetime(AAPL['date']), AAPL['adj_close'], color='#A6CEE3', legend_label='AAPL')\np1.line(datetime(GOOG['date']), GOOG['adj_close'], color='#B2DF8A', legend_label='GOOG')\np1.line(datetime(IBM['date']), IBM['adj_close'], color='#33A02C', legend_label='IBM')\np1.line(datetime(MSFT['date']), MSFT['adj_close'], color='#FB9A99', legend_label='MSFT')\np1.legend.location = \"top_left\"\n\naapl = np.array(AAPL['adj_close'])\naapl_dates = np.array(AAPL['date'], dtype=np.datetime64)\n\nwindow_size = 30\nwindow = np.ones(window_size)/float(window_size)\naapl_avg = np.convolve(aapl, window, 'same')\n\np2 = figure(x_axis_type=\"datetime\", title=\"AAPL One-Month Average\")\np2.grid.grid_line_alpha = 0\np2.xaxis.axis_label = 'Date'\np2.yaxis.axis_label = 'Price'\np2.ygrid.band_fill_color = \"olive\"\np2.ygrid.band_fill_alpha = 0.1\n\np2.circle(aapl_dates, aapl, size=4, legend_label='close',\n color='darkgrey', alpha=0.2)\n\np2.line(aapl_dates, aapl_avg, legend_label='avg', color='navy')\np2.legend.location = \"top_left\"\n\noutput_file(\"stocks.html\", title=\"stocks.py example\")\n\nshow(gridplot([[p1,p2]], plot_width=400, plot_height=400)) # open a browser\n"
] | [
[
"numpy.array",
"numpy.ones",
"numpy.convolve"
]
] |
samtx/pyapprox | [
"c926d910e30fbcfed7d0621175d3b0268d59f852"
] | [
"pyapprox/optimization.py"
] | [
"import numpy as np\nfrom scipy.optimize import minimize, Bounds\nfrom functools import partial\nfrom scipy.stats import gaussian_kde as KDE\nfrom pyapprox.configure_plots import *\nimport scipy.stats as ss\nfrom pyapprox.utilities import get_all_sample_combinations\n\ndef approx_jacobian(func, x, *args, epsilon=np.sqrt(np.finfo(float).eps)):\n x0 = np.asfarray(x)\n assert x0.ndim == 1 or x0.shape[1] == 1\n f0 = np.atleast_1d(func(*((x0,)+args)))\n if f0.ndim == 2:\n assert f0.shape[1] == 1\n f0 = f0[:, 0]\n jac = np.zeros([len(x0), len(f0)])\n dx = np.zeros(x0.shape)\n for i in range(len(x0)):\n dx[i] = epsilon\n f1 = func(*((x0+dx,)+args))\n if f1.ndim==2:\n assert f1.shape[1] == 1\n f1 = f1[:,0]\n jac[i] = (f1 - f0)/epsilon\n dx[i] = 0.0\n\n return jac.transpose()\n \n\ndef eval_function_at_multiple_design_and_random_samples(function,uq_samples,design_samples):\n \"\"\"\n for functions which only take 1d arrays for uq_samples and design_samples\n loop over all combinations and evaluate function at each combination\n\n design_samples vary slowest and uq_samples vary fastest\n\n Let design samples = [[1,2],[2,3]]\n uq_samples = [[0, 0, 0],[0, 1, 2]]\n Then samples will be\n\n ([1, 2], [0, 0, 0])\n ([1, 2], [0, 1, 2])\n ([3, 4], [0, 0, 0])\n ([3, 4], [0, 1, 2])\n\n function(uq_samples,design_samples)\n \"\"\"\n vals = []\n # put design samples first so that samples iterates over uq_samples fastest\n samples = get_all_sample_combinations(design_samples,uq_samples)\n for xx,zz in zip(\n samples[:design_samples.shape[0]].T,\n samples[design_samples.shape[0]:].T):\n # flip xx,zz because functions assumed to take uq_samples then\n # design_samples\n vals.append(function(zz,xx))\n return np.asarray(vals)\n\ndef eval_mc_based_jacobian_at_multiple_design_samples(grad,stat_func,\n uq_samples,design_samples):\n \"\"\"\n Alternatively I could use\n jacobian = [np.mean([constraint_grad_single(z,x) for z in zz.T],axis=0) for x in xx.T]\n But I think this implementation will allow better use of concurent evaluations in the \n future. For example eval_function_at_multiple_design_and_random_samples could\n utilize an asynchronous call over all the sample combinations\n\n TODO combine uq_samples and design samples into one matrix and assume functions\n always take a single matrix and not two matrices\n \"\"\"\n grads = eval_function_at_multiple_design_and_random_samples(\n grad,uq_samples,design_samples)\n \n ndesign_samples = design_samples.shape[1]\n nuq_samples = uq_samples.shape[1]\n jacobian = np.array(\n [stat_func(grads[ii*nuq_samples:(ii+1)*nuq_samples])\n for ii in range(ndesign_samples)])\n return jacobian\n\ndef check_inputs(uq_samples,design_samples):\n if design_samples.ndim==1:\n design_samples = design_samples[:,np.newaxis]\n if uq_samples is not None and uq_samples.ndim==1:\n uq_samples = design_samples[:,np.newaxis]\n if (uq_samples is not None and\n (design_samples.shape[1]>1 and uq_samples.shape[1]>1)):\n assert design_samples.shape[1]==uq_samples.shape[1]\n return uq_samples,design_samples\n\ndef deterministic_lower_bound_constraint(constraint_function,lower_bound,\n uq_samples,design_samples):\n uq_samples,design_samples = check_inputs(uq_samples,design_samples)\n assert design_samples.shape[1]==1\n val = lower_bound-constraint_function(uq_samples,design_samples)\n # scipy minimize enforces constraints are non-negative so use negative here\n # to enforce upper bound\n return -val\n\ndef variance_lower_bound_constraint(constraint_function,lower_bound,uq_samples,\n design_samples):\n uq_samples,design_samples = check_inputs(uq_samples,design_samples)\n assert design_samples.shape[1]==1\n # scipy minimize enforces constraints are non-negative\n vals = constraint_function(uq_samples,design_samples)\n val = lower_bound-np.std(vals)**2\n # scipy minimize enforces constraints are non-negative so use negative here\n # to enforce upper bound\n return -val\n\ndef mean_lower_bound_constraint(constraint_function,lower_bound,uq_samples,\n design_samples):\n uq_samples,design_samples = check_inputs(uq_samples,design_samples)\n assert design_samples.shape[1]==1\n # scipy minimize enforces constraints are non-negative\n vals = constraint_function(uq_samples,design_samples)\n val = lower_bound-np.mean(vals)**2\n # scipy minimize enforces constraints are non-negative so use negative here\n # to enforce upper bound\n return -val\n\ndef mean_lower_bound_constraint_jacobian(constraint_function_jacobian,uq_samples,\n design_samples):\n uq_samples,design_samples = check_inputs(uq_samples,design_samples)\n assert design_samples.shape[1]==1\n # scipy minimize enforces constraints are non-negative\n vals = constraint_function_jacobian(uq_samples,design_samples)\n val = -np.mean(vals)**2\n # scipy minimize enforces constraints are non-negative so use negative here\n # to enforce upper bound\n return -val\n\ndef quantile_lower_bound_constraint(constraint_function,quantile,lower_bound,\n uq_samples,design_samples):\n uq_samples,design_samples = check_inputs(uq_samples,design_samples)\n assert design_samples.shape[1]==1\n vals = constraint_function(uq_samples,design_samples)\n val = (lower_bound-ss.mstats.mquantiles(vals,prob=[quantile]))\n # scipy minimize enforces constraints are non-negative so use negative here\n # to enforce lower bound\n return -val\n\nfrom pyapprox.cvar_regression import smooth_conditional_value_at_risk, \\\n conditional_value_at_risk\ndef cvar_lower_bound_constraint(constraint_function,quantile,lower_bound,eps,\n uq_samples,design_samples):\n uq_samples,design_samples = check_inputs(uq_samples,design_samples)\n assert design_samples.shape[1]==1\n vals = constraint_function(uq_samples,design_samples)\n # -vals because we want to minimize lower tail\n val = (lower_bound-smooth_conditional_value_at_risk(0,eps,quantile,-vals))\n #val = (lower_bound-conditional_value_at_risk(-vals,quantile))\n return val\n\nclass MultipleConstraints(object):\n def __init__(self,constraints):\n self.constraints=constraints\n\n def __call__(self,design_sample,constraint_idx=None):\n if constraint_idx is None:\n constraint_idx = np.arange(len(self.constraints))\n nconstraints = len(constraint_idx)\n vals = np.empty(nconstraints)\n for ii,jj in enumerate(constraint_idx):\n vals[ii]=self.constraints[jj](design_sample)\n return vals\n\nclass MCStatisticConstraint(object):\n def __init__(self,constraint_function,generate_samples,info):\n self.constraint_function = constraint_function\n self.generate_samples=generate_samples\n self.info=info\n\n def __call__(self,design_samples):\n uq_samples = self.generate_samples()\n constraint_type=self.info['type']\n if constraint_type=='quantile':\n quantile = self.info['quantile']\n lower_bound = self.info['lower_bound']\n return quantile_lower_bound_constraint(\n self.constraint_function,quantile,lower_bound,\n uq_samples,design_samples)\n elif constraint_type=='cvar':\n quantile = self.info['quantile']\n lower_bound = self.info['lower_bound']\n eps = self.info['smoothing_eps']\n return cvar_lower_bound_constraint(\n constraint_functions[ii], quantile, lower_bound, eps,\n uq_samples, design_samples)\n elif constraint_type=='var':\n var_lower_bound = self.info['lower_bound']\n return variance_lower_bound_constraint(\n constraint_functions[ii],lower_bound,uq_samples,design_samples)\n else:\n raise Exception(\n 'constraint type (%s) not implemented'%constraint_type[ii])\n\nclass DeterministicConstraint(object):\n def __init__(self,constraint_function,info):\n self.constraint_function = constraint_function\n self.info=info\n\n def __call__(self,design_samples):\n lower_bound = self.info['lower_bound']\n uq_nominal_sample = self.info['uq_nominal_sample']\n return deterministic_lower_bound_constraint(\n self.constraint_function,lower_bound,uq_nominal_sample,\n design_samples)\n \ndef setup_inequality_constraints(constraint_functions,constraints_info,\n uq_samples):\n constraints = []\n for ii in range(len(constraint_functions)):\n info = constraints_info[ii]\n constraint_type = info['type']\n if constraint_type=='quantile':\n quantile = info['quantile']\n quantile_lower_bound = info['quantile_lower_bound']\n ineq_cons_fun = partial(\n quantile_lower_bound_constraint, constraint_functions[ii],\n quantile, quantile_lower_bound, uq_samples)\n elif constraint_type=='cvar':\n quantile = info['quantile']\n quantile_lower_bound = info['cvar_lower_bound']\n eps = info['smoothing_eps']\n ineq_cons_fun = partial(\n cvar_lower_bound_constraint, constraint_functions[ii],\n quantile, quantile_lower_bound, eps, uq_samples)\n elif constraint_type=='var':\n var_lower_bound = info['var_lower_bound']\n ineq_cons_fun = partial(\n variance_lower_bound_constraint, constraint_functions[ii],\n var_lower_bound, uq_samples)\n elif constraint_type=='deterministic':\n lower_bound = info['lower_bound']\n ineq_cons_fun = partial(\n deterministic_lower_bound_constraint, constraint_functions[ii],\n lower_bound, uq_samples)\n else:\n raise Exception(\n 'constraint type (%s) not implemented'%constraint_type[ii])\n ineq_cons = {'type': 'ineq', 'fun' : ineq_cons_fun}\n constraints.append(ineq_cons)\n return constraints\n\ndef run_design(objective, init_design_sample,\n constraints, bounds, optim_options):\n\n opt_history = [init_design_sample[:,0]]\n def callback(xk):\n opt_history.append(xk)\n #print(objective(xk))\n #print([constraints[ii]['fun'](xk) for ii in [0,1]])\n\n # opt_method = 'SLSQP'\n # res = minimize(\n # objective, init_design_sample[:,0], method=opt_method, jac=None,\n # constraints=constraints,\n # options=optim_options,bounds=bounds,callback=callback)\n\n from scipy.optimize import fmin_slsqp\n res = fmin_slsqp(objective, init_design_sample[:,0], f_ieqcons=constraints,\n bounds=bounds, callback=callback, full_output=True)#, **optim_options)\n class result():\n def __init__(self,x,fun):\n self.x=np.atleast_1d(x)\n self.fun=fun\n res = result(res[0],res[1])\n\n opt_history = (np.array(opt_history)).T\n return res, opt_history\n\ndef plot_optimization_history(obj_function,constraints,uq_samples,opt_history,\n plot_limits):\n\n # fig,axs=plot_optimization_objective_and_constraints_2D(\n # [constraints[ii]['fun'] for ii in range(len(constraints))],\n # partial(obj_function,uq_samples[:,0]),plot_limits)\n\n fig,axs=plot_optimization_objective_and_constraints_2D(\n constraints,partial(obj_function,uq_samples[:,0]),plot_limits)\n # objective can only be evaluated at one uq_sample thus use of\n # uq_samples[:,0]\n \n for ii in range(len(axs)):\n axs[ii].plot(opt_history[0,:],opt_history[1,:],'ko')\n for jj, txt in enumerate(range(opt_history.shape[1])):\n axs[ii].annotate(\n '%d'%txt,(opt_history[0,jj],opt_history[1,jj]))\n return fig,axs\n\n#def plot_optimization_objective_and_constraints_2D(\n# constraint_functions,objective,plot_limits):\n\ndef plot_optimization_objective_and_constraints_2D(\n constraints,objective,plot_limits):\n from pyapprox.visualization import get_meshgrid_function_data\n num_pts_1d = 100; num_contour_levels=30\n fig,axs=plt.subplots(1,3,figsize=(3*8,6))\n #for ii in range(len(constraint_functions)+1):\n for ii in range(len(constraints.constraints)+1):\n\n #if ii==len(constraint_functions):\n if ii==len(constraints.constraints):\n function=objective\n else:\n # def function(design_samples):\n # vals = np.empty((design_samples.shape[1]))\n # for jj in range(design_samples.shape[1]):\n # vals[jj]=constraint_functions[ii](design_samples[:,jj])\n # return vals\n def function(design_samples):\n vals = np.empty((design_samples.shape[1]))\n for jj in range(design_samples.shape[1]):\n vals[jj]=constraints(design_samples[:,jj],[ii])\n return vals\n \n X,Y,Z = get_meshgrid_function_data(\n function, plot_limits, num_pts_1d)\n norm = None\n cset = axs[ii].contourf(\n X, Y, Z, levels=np.linspace(Z.min(),Z.max(),num_contour_levels),\n cmap=mpl.cm.coolwarm,\n norm=norm)\n #for kk in range(len(constraint_functions)):\n for kk in range(len(constraints.constraints)):\n if ii==kk:\n ls = '-'\n else:\n ls = '--'\n axs[kk].contour(X,Y,Z,levels=[0],colors='k',linestyles=ls)\n plt.colorbar(cset,ax=axs[ii])\n\n return fig,axs\n\ndef plot_constraint_pdfs(constraint_functions,uq_samples,design_sample,\n fig_pdf=None,axs_pdf=None,label=None,color=None):\n colors = ['b','gray']\n nconstraints = len(constraint_functions)\n if axs_pdf is None:\n fig_pdf,axs_pdf = plt.subplots(1,nconstraints,figsize=(nconstraints*8,6))\n for ii in range(nconstraints):\n # evaluate constraint function at each of the uq samples\n constraint_function_vals = constraint_functions[ii](\n uq_samples,design_sample)\n\n constraint_kde = KDE(constraint_function_vals)\n yy = np.linspace(constraint_function_vals.min(),\n constraint_function_vals.max(),101)\n\n axs_pdf[ii].fill_between(yy,0,constraint_kde(yy),alpha=0.5,label=label,\n color=color)\n axs_pdf[ii].axvline(0,color='k')\n #axs_pdf[ii].axvline(constraints[ii]['fun'](design_sample),color='r')\n return fig_pdf,axs_pdf\n \ndef plot_constraint_cdfs(constraints,constraint_functions,uq_samples,\n design_sample,quantile,fig_cdf,axs_cdf=None,label=None,\n color=None):\n nconstraints = len(constraint_functions)\n if axs_cdf is None:\n fig_cdf,axs_cdf = plt.subplots(\n 1,nconstraints,figsize=(nconstraints*8,6))\n\n for ii in range(nconstraints):\n constraint_function_vals = constraint_functions[ii](\n uq_samples,design_sample)\n\n cvar = (conditional_value_at_risk(-constraint_function_vals,0.9))\n cvars = (smooth_conditional_value_at_risk(0,1e-3,0.9,-constraint_function_vals))\n print ('cvar',cvar)\n print ('cvars',cvars)\n #constraint_val = constraints[ii]['fun'](design_sample)\n constraint_val = constraints(design_sample,[ii])\n constraint_function_vals.sort()\n cdf_vals = np.linspace(0,1,constraint_function_vals.shape[0]+1)[1:]\n axs_cdf[ii].plot(constraint_function_vals,cdf_vals,label=label,\n color=color)\n #I = np.where(constraint_function_vals<=constraint_val)[0]\n I = np.where(constraint_function_vals<=0)[0]\n axs_cdf[ii].fill_between(\n constraint_function_vals[I],0,cdf_vals[I],alpha=0.5,color=color)\n axs_cdf[ii].axvline(0,color='k')\n J = np.where(constraint_function_vals<=0)[0]\n #print (J.shape[0]/float(constraint_function_vals.shape[0]),'p failure',constraint_val,J.shape[0])\n # Compute the constraint value. This combines constraint_function_vals\n # into a scalar value\n #axs_cdf[ii].axvline(constraint_val,color='r')\n #axs_cdf[ii].plot(\n # np.linspace(constraint_function_vals[0],constraint_val,101),\n # quantile*np.ones(101),'-r')\n #axs_cdf[ii].set_yticks(list(axs_cdf[ii].get_yticks()) + [quantile])\n axs_cdf[ii].set_ylim(0,1.05)\n axs_cdf[ii].set_xlim(\n constraint_function_vals[0],constraint_function_vals[-1])\n return fig_cdf, axs_cdf\n\n\ndef check_gradients(fun, jac, zz, plot=False, disp=True, rel=True):\n \"\"\"\n Compare a user specified jacobian with the jacobian computed with finite\n difference with multiple step sizes.\n\n Parameters\n ---------\n fun : callable\n\n A function with signature\n\n ``fun(z) -> np.ndarray``\n\n where ``z`` is a 2D np.ndarray with shape (nvars, 1) and the\n output is a 2D np.ndarray with shape (nqoi, 1)\n\n jac : callable\n The jacobian of ``fun`` with signature\n\n ``jac(z) -> np.ndarray``\n\n where ``z`` is a 2D np.ndarray with shape (nvars, 1) and the\n output is a 2D np.ndarray with shape (nqoi, nvars)\n\n zz : np.ndarray (nvars, 1)\n A sample of ``z`` at which to compute the gradient\n\n plot : boolean\n Plot the errors as a function of the finite difference step size\n\n disp : boolean\n True - print the errors\n False - do not print\n\n rel : boolean\n True - compute the relative error in the directional derivative, \n i.e. the absolute error divided by the directional derivative using \n ``jac``.\n False - compute the absolute error in the directional derivative\n\n Returns\n -------\n errors : np.ndarray (14, nqoi)\n The errors in the directional derivative of ``fun`` at 14 different \n values of finite difference tolerance for each quantity of interest\n \"\"\"\n assert zz.ndim == 2\n assert zz.shape[1] == 1\n if callable(jac):\n function_val = fun(zz)\n grad_val = jac(zz)\n elif jac==True:\n function_val, grad_val = fun(zz)\n direction = np.random.normal(0, 1, (zz.shape[0], 1))\n direction /= np.linalg.norm(direction)\n directional_derivative = grad_val.squeeze().dot(direction).squeeze()\n fd_eps = np.logspace(-13, 0, 14)[::-1]\n errors = []\n row_format = \"{:<25} {:<25} {:<25}\"\n if disp:\n if rel:\n print(\n row_format.format(\n \"Eps\", \"Rel. Errors (max)\", \"Rel. Errors (min)\"))\n else:\n print(row_format.format(\"Eps\", \"Errors (max)\", \"Errors (min)\"))\n for ii in range(fd_eps.shape[0]):\n zz_perturbed = zz.copy()+fd_eps[ii]*direction\n perturbed_function_val = fun(zz_perturbed)\n if jac==True:\n perturbed_function_val = perturbed_function_val[0].squeeze()\n fd_directional_derivative = (\n perturbed_function_val-function_val).squeeze()/fd_eps[ii]\n errors.append(np.absolute(\n fd_directional_derivative.reshape(directional_derivative.shape)-\n directional_derivative))\n if rel:\n errors[-1]/=np.absolute(directional_derivative)\n if disp:\n print(row_format.format(fd_eps[ii], errors[ii].max(),\n errors[ii].min()))\n #print(fd_directional_derivative, directional_derivative)\n\n if plot:\n plt.loglog(fd_eps, errors, 'o-')\n plt.ylabel(r'$\\lvert\\nabla_\\epsilon f\\cdot p-\\nabla f\\cdot p\\rvert$')\n plt.xlabel(r'$\\epsilon$')\n plt.show()\n\n return np.asarray(errors)\n\ndef check_hessian(jac,hessian_matvec,zz,plot=False,disp=True):\n \"\"\"\n Compare a user specified Hessian matrix-vector product with the \n Hessian matrix vector produced computed with finite\n difference with multiple step sizes using a user specified jacobian.\n\n Parameters\n ---------\n jac : callable\n The jacobian with signature\n\n ``jac(z) -> np.ndarray``\n\n where ``z`` is a 2D np.ndarray with shape (nvars,1) and the\n output is a 2D np.ndarray with shape (nqoi,nvars)\n\n hessian_matvec : callable\n A function implementing the hessian matrix-vector product with signature\n\n ``hessian_matvec(z,p) -> np.ndarray``\n\n where ``z`` is a 2D np.ndarray with shape (nvars,1), ``p`` is\n an arbitrary vector with shape (nvars,1) and the\n output is a 2D np.ndarray with shape (nqoi,nvars)\n\n zz : np.ndarray (nvars,1)\n A sample of ``z`` at which to compute the gradient\n\n plot : boolean\n Plot the errors as a function of the finite difference step size\n\n disp : boolean\n True - print the errors\n False - do not print\n\n rel : boolean\n True - compute the relative error in the directional derivative, \n i.e. the absolute error divided by the directional derivative using \n ``jac``.\n False - compute the absolute error in the directional derivative\n\n Returns\n -------\n errors : np.ndarray (14,nqoi)\n The errors in the directional derivative of ``jac`` at 14 different \n values of finite difference tolerance for each quantity of interest\n \"\"\"\n assert zz.ndim==2\n assert zz.shape[1]==1\n grad = jac(zz)\n direction = np.random.normal(0,1,(zz.shape[0],1))\n direction /= np.linalg.norm(direction)\n directional_derivative = hessian_matvec(zz,direction)\n fd_eps = np.logspace(-13,0,14)[::-1]\n errors = []\n row_format = \"{:<25} {:<25} {:<25}\"\n if disp:\n print(row_format.format(\"Eps\",\"Errors (max)\",\"Errors (min)\"))\n for ii in range(fd_eps.shape[0]):\n zz_perturbed = zz.copy()+fd_eps[ii]*direction\n perturbed_grad = jac(zz_perturbed)\n fd_directional_derivative = (perturbed_grad-grad)/fd_eps[ii]\n errors.append(np.absolute(\n fd_directional_derivative-directional_derivative))\n if disp:\n print(row_format.format(fd_eps[ii],errors[ii].max(),\n errors[ii].min()))\n #print(fd_directional_derivative,directional_derivative)\n\n if plot:\n plt.loglog(fd_eps,errors,'o-')\n plt.ylabel(r'$\\lvert\\nabla^2_\\epsilon \\cdot p f-\\nabla^2 f\\cdot p\\rvert$')\n plt.xlabel(r'$\\epsilon$')\n plt.show()\n\n return np.asarray(errors)\n\ndef expectation_fun(values,weights):\n assert values.shape[0]%weights.shape[0]==0\n nqoi = values.shape[0]//weights.shape[0]\n nsamples = values.shape[0]//nqoi\n assert nqoi==1\n fun_vals = (values.T.dot(weights)).T\n return fun_vals\n\ndef expectation_jac(jac_values,weights):\n assert jac_values.shape[0]%weights.shape[0]==0\n nqoi = jac_values.shape[0]//weights.shape[0]\n nsamples = jac_values.shape[0]//nqoi\n num_vars = jac_values.shape[1]\n assert nqoi==1\n jac = (jac_values.T.dot(weights)).T\n return jac\n\nfrom pyapprox.cvar_regression import smooth_max_function_first_derivative,\\\n smooth_max_function_second_derivative\ndef smooth_prob_failure_fun(smoother_type,eps,tol,values,weights):\n assert values.shape[0]%weights.shape[0]==0\n nqoi = values.shape[0]//weights.shape[0]\n assert nqoi==1\n nsamples = values.shape[0]//nqoi\n heaviside_vals = smooth_max_function_first_derivative(\n smoother_type,eps,values-tol)\n fun_vals = (heaviside_vals.dot(weights)).T\n #print(fun_vals.shape)\n return fun_vals\n\ndef smooth_prob_failure_jac(smoother_type,eps,tol,jac_values,weights):\n assert jac_values.shape[0]%weights.shape[0]==0\n nqoi = jac_values.shape[0]//weights.shape[0]\n assert nqoi==1\n nsamples = jac_values.shape[0]//nqoi\n num_vars = jac_values.shape[1]\n grad_heaviside_vals = smooth_max_function_second_derivative(\n smoother_type,eps,jac_values-tol)\n jac = (grad_heaviside_vals*jac_values).T.dot(weights)[np.newaxis,:]\n print(jac_values.max(axis=0),'m',eps)\n\n return jac\n\ndef generate_monte_carlo_quadrature_data(\n generate_random_samples,num_vars,design_var_indices,fun,seed=None):\n if seed is not None:\n np.random.seed(seed)\n samples = generate_random_samples()\n weights = np.ones(samples.shape[1])/samples.shape[1]\n values = fun(samples)\n return samples,weights,values\n\nfrom pyapprox.models.wrappers import ActiveSetVariableModel\nclass StatisticalConstraint(object):\n \"\"\"\n Notes\n -----\n TODO ensure the following.\n\n This class unifies the jac=True and callable(jac)=True interfaces.\n The interface is used for passing to optimizers that need the fun and jac functions\n to be separate. This is often good practice as it avoids computing \n jac when only fun is required.\n If jac=True the jacobian is stored and returned when self.jac is called\n \"\"\"\n \n def __init__(self,fun,jac,stats_fun,stats_jac,num_vars,\n design_var_indices,generate_sample_data,bound=None,\n upper_bound=True,isobjective=False):\n self.fun,self.jac,self.stats_fun=fun,jac,stats_fun\n self.stats_jac=stats_jac\n self.num_vars=num_vars\n self.design_var_indices=design_var_indices\n self.random_var_indices = np.delete(\n np.arange(self.num_vars),self.design_var_indices)\n self.generate_sample_data=generate_sample_data\n self.bound=bound\n self.upper_bound=upper_bound\n self.isobjective=isobjective\n\n self.design_sample = None\n self.jac_values = None\n self.samples = None\n \n if self.stats_jac is not None and self.jac is None:\n msg = 'stats_jac requries jac to be defined'\n raise Exception(msg)\n if self.jac is not None and self.stats_jac is None:\n msg = 'jac will be ignored because stats_jac was not defined'\n raise Exception(msg)\n\n def generate_shared_data(self,design_sample):\n self.design_sample=design_sample.copy()\n\n fun = ActiveSetVariableModel(self.fun,self.num_vars,design_sample,\n self.random_var_indices)\n data = self.generate_sample_data(fun)\n self.samples,self.weights,self.fun_values = data[:3]\n assert self.samples.shape[0]==\\\n self.num_vars-self.design_var_indices.shape[0]\n assert self.samples.shape[1]==self.weights.shape[0]\n #assert self.samples.shape[1]==self.fun_values.shape[0]\n if not callable(self.jac) and self.jac:\n # consider whether to support self.jac=True. It seems appealing\n # if using gradients from adjoint PDE simulation which requires \n # data used to compute function values and thus better to do at the\n # time the function values are obtained. Challenge is defining the\n # correct output interface and only computing gradients if self.jac\n # has been called and not if self.__call__ is called.\n raise Exception (\"Not yet implemented\")\n self.jac_values = data[3]\n \n def __call__(self,design_sample):\n if design_sample.ndim==1:\n design_sample = design_sample[:,np.newaxis]\n self.generate_shared_data(design_sample)\n nsamples = self.weights.shape[0]\n nqoi = self.fun_values.shape[1]\n #print(self.fun_values)\n values = np.empty((nqoi))\n for ii in range(nqoi):\n values[ii] = self.stats_fun(\n self.fun_values[:,ii:ii+1],self.weights)\n \n #print('b',np.where(self.fun_values[:,ii:ii+1]>0)[0].shape[0]/nsamples)\n #print('c',values[ii])\n #print(self.fun_values.min(),self.fun_values.max())\n if self.bound is not None:\n values = values-self.bound\n if self.upper_bound:\n values *= -1\n if self.isobjective:\n values= values[0]\n return values\n\n def jacobian(self,design_sample):\n if design_sample.ndim==1:\n design_sample = design_sample[:,np.newaxis]\n if (np.array_equal(design_sample,self.design_sample) and\n self.jac_values is not None):\n jac_values = self.jac_values\n else:\n jac = ActiveSetVariableModel(\n self.jac,self.num_vars,self.samples,self.design_var_indices)\n jac_values = jac(design_sample)\n nsamples = self.weights.shape[0]\n nqoi = self.fun_values.shape[1]\n nvars = jac_values.shape[1]\n constraint_jac = np.empty((nqoi,nvars))\n for ii in range(nqoi):\n constraint_jac[ii] = self.stats_jac(\n jac_values[ii*nsamples:(ii+1)*nsamples,:],self.weights)\n if self.bound is not None and self.upper_bound:\n constraint_jac *= -1\n return constraint_jac.squeeze()\n\nclass PyapproxFunctionAsScipyMinimizeObjective(object):\n def __init__(self,fun):\n self.fun=fun\n def __call__(self,scipy_sample):\n assert scipy_sample.ndim==1\n data = self.fun(scipy_sample[:,np.newaxis])\n if not np.isscalar(data):\n assert len(data)==2\n val = data[0]\n assert np.isscalar(val)\n assert data[1].ndim==2 and data[1].shape[0]==1\n jac = data[1][0,:]\n return val,jac\n return data\n\nclass ScipyMinimizeObjectiveAsPyapproxFunction(object):\n def __init__(self,fun):\n self.fun=fun\n def __call__(self,pyapprox_sample):\n assert pyapprox_sample.ndim==2 and pyapprox_sample.shape[1]==1\n data = self.fun(pyapprox_sample[:,0])\n if not np.isscalar(data):\n assert len(data)==2\n val = data[0]\n assert np.isscalar(val)\n assert data[1].ndim==2 and data[1].shape[0]==1\n jac = data[1][0,:]\n return val,jac\n return data\n\nclass ScipyMinimizeObjectiveJacAsPyapproxJac(object):\n def __init__(self,jac):\n self.jac=jac\n def __call__(self,pyapprox_sample):\n assert pyapprox_sample.ndim==2 and pyapprox_sample.shape[1]==1\n grad = self.jac(pyapprox_sample[:,0])\n return grad[np.newaxis,:]\n"
] | [
[
"numpy.ones",
"numpy.random.seed",
"numpy.asarray",
"scipy.stats.gaussian_kde",
"numpy.isscalar",
"numpy.absolute",
"scipy.stats.mstats.mquantiles",
"numpy.where",
"numpy.linspace",
"numpy.mean",
"numpy.zeros",
"scipy.optimize.fmin_slsqp",
"numpy.random.normal",
"numpy.arange",
"numpy.std",
"numpy.finfo",
"numpy.linalg.norm",
"numpy.empty",
"numpy.atleast_1d",
"numpy.array_equal",
"numpy.logspace",
"numpy.array",
"numpy.asfarray"
]
] |
santisoler/xarray | [
"2bb5d20fb2b4158390ab05aa6bf598b78f2caa9d"
] | [
"xarray/tutorial.py"
] | [
"\"\"\"\nUseful for:\n\n* users learning xarray\n* building tutorials in the documentation.\n\n\"\"\"\nimport os\nimport pathlib\n\nimport numpy as np\n\nfrom .backends.api import open_dataset as _open_dataset\nfrom .backends.rasterio_ import open_rasterio as _open_rasterio\nfrom .core.dataarray import DataArray\nfrom .core.dataset import Dataset\n\n_default_cache_dir_name = \"xarray_tutorial_data\"\nbase_url = \"https://github.com/pydata/xarray-data\"\nversion = \"master\"\n\n\ndef _construct_cache_dir(path):\n import pooch\n\n if isinstance(path, pathlib.Path):\n path = os.fspath(path)\n elif path is None:\n path = pooch.os_cache(_default_cache_dir_name)\n\n return path\n\n\nexternal_urls = {} # type: dict\nexternal_rasterio_urls = {\n \"RGB.byte\": \"https://github.com/mapbox/rasterio/raw/1.2.1/tests/data/RGB.byte.tif\",\n \"shade\": \"https://github.com/mapbox/rasterio/raw/1.2.1/tests/data/shade.tif\",\n}\n\n\n# idea borrowed from Seaborn\ndef open_dataset(\n name,\n cache=True,\n cache_dir=None,\n **kws,\n):\n \"\"\"\n Open a dataset from the online repository (requires internet).\n\n If a local copy is found then always use that to avoid network traffic.\n\n Available datasets:\n\n * ``\"air_temperature\"``: NCEP reanalysis subset\n * ``\"rasm\"``: Output of the Regional Arctic System Model (RASM)\n * ``\"ROMS_example\"``: Regional Ocean Model System (ROMS) output\n * ``\"tiny\"``: small synthetic dataset with a 1D data variable\n * ``\"era5-2mt-2019-03-uk.grib\"``: ERA5 temperature data over the UK\n * ``\"eraint_uvz\"``: data from ERA-Interim reanalysis, monthly averages of upper level data\n\n Parameters\n ----------\n name : str\n Name of the file containing the dataset.\n e.g. 'air_temperature'\n cache_dir : path-like, optional\n The directory in which to search for and write cached data.\n cache : bool, optional\n If True, then cache data locally for use on subsequent calls\n **kws : dict, optional\n Passed to xarray.open_dataset\n\n See Also\n --------\n xarray.open_dataset\n \"\"\"\n try:\n import pooch\n except ImportError as e:\n raise ImportError(\n \"tutorial.open_dataset depends on pooch to download and manage datasets.\"\n \" To proceed please install pooch.\"\n ) from e\n\n logger = pooch.get_logger()\n logger.setLevel(\"WARNING\")\n\n cache_dir = _construct_cache_dir(cache_dir)\n if name in external_urls:\n url = external_urls[name]\n else:\n path = pathlib.Path(name)\n if not path.suffix:\n # process the name\n default_extension = \".nc\"\n path = path.with_suffix(default_extension)\n\n url = f\"{base_url}/raw/{version}/{path.name}\"\n\n # retrieve the file\n filepath = pooch.retrieve(url=url, known_hash=None, path=cache_dir)\n ds = _open_dataset(filepath, **kws)\n if not cache:\n ds = ds.load()\n pathlib.Path(filepath).unlink()\n\n return ds\n\n\ndef open_rasterio(\n name,\n engine=None,\n cache=True,\n cache_dir=None,\n **kws,\n):\n \"\"\"\n Open a rasterio dataset from the online repository (requires internet).\n\n If a local copy is found then always use that to avoid network traffic.\n\n Available datasets:\n\n * ``\"RGB.byte\"``: TIFF file derived from USGS Landsat 7 ETM imagery.\n * ``\"shade\"``: TIFF file derived from from USGS SRTM 90 data\n\n ``RGB.byte`` and ``shade`` are downloaded from the ``rasterio`` repository [1]_.\n\n Parameters\n ----------\n name : str\n Name of the file containing the dataset.\n e.g. 'RGB.byte'\n cache_dir : path-like, optional\n The directory in which to search for and write cached data.\n cache : bool, optional\n If True, then cache data locally for use on subsequent calls\n **kws : dict, optional\n Passed to xarray.open_rasterio\n\n See Also\n --------\n xarray.open_rasterio\n\n References\n ----------\n .. [1] https://github.com/mapbox/rasterio\n \"\"\"\n try:\n import pooch\n except ImportError as e:\n raise ImportError(\n \"tutorial.open_rasterio depends on pooch to download and manage datasets.\"\n \" To proceed please install pooch.\"\n ) from e\n\n logger = pooch.get_logger()\n logger.setLevel(\"WARNING\")\n\n cache_dir = _construct_cache_dir(cache_dir)\n url = external_rasterio_urls.get(name)\n if url is None:\n raise ValueError(f\"unknown rasterio dataset: {name}\")\n\n # retrieve the file\n filepath = pooch.retrieve(url=url, known_hash=None, path=cache_dir)\n arr = _open_rasterio(filepath, **kws)\n if not cache:\n arr = arr.load()\n pathlib.Path(filepath).unlink()\n\n return arr\n\n\ndef load_dataset(*args, **kwargs):\n \"\"\"\n Open, load into memory, and close a dataset from the online repository\n (requires internet).\n\n See Also\n --------\n open_dataset\n \"\"\"\n with open_dataset(*args, **kwargs) as ds:\n return ds.load()\n\n\ndef scatter_example_dataset():\n A = DataArray(\n np.zeros([3, 11, 4, 4]),\n dims=[\"x\", \"y\", \"z\", \"w\"],\n coords=[\n np.arange(3),\n np.linspace(0, 1, 11),\n np.arange(4),\n 0.1 * np.random.randn(4),\n ],\n )\n B = 0.1 * A.x ** 2 + A.y ** 2.5 + 0.1 * A.z * A.w\n A = -0.1 * A.x + A.y / (5 + A.z) + A.w\n ds = Dataset({\"A\": A, \"B\": B})\n ds[\"w\"] = [\"one\", \"two\", \"three\", \"five\"]\n\n ds.x.attrs[\"units\"] = \"xunits\"\n ds.y.attrs[\"units\"] = \"yunits\"\n ds.z.attrs[\"units\"] = \"zunits\"\n ds.w.attrs[\"units\"] = \"wunits\"\n\n ds.A.attrs[\"units\"] = \"Aunits\"\n ds.B.attrs[\"units\"] = \"Bunits\"\n\n return ds\n"
] | [
[
"numpy.arange",
"numpy.linspace",
"numpy.random.randn",
"numpy.zeros"
]
] |
hassenmorad/Home-to-Income-Ratio | [
"777754693150ed6f777d084dbace7b8189317c55"
] | [
"Scripts/mort_by_pop_den_5yr_0816.py"
] | [
"# Mortgagea share of income by population density\nimport pandas as pd\nimport numpy as np\nimport array\n\nfile = pd.read_csv('county_rent_mort_inc_units_5yr.csv')\n\nyrs_dict = {}\nfor year in range(2008, 2017):\n print(year)\n yr_df = file[file.Year == year].dropna(subset=['Housing_Den'])\n yr_df.Total_Owned = yr_df.Total_Owned.astype(int) # For np.full in line 32\n \n # FIPS grouped by county population density\n county1k = yr_df.FIPS[(yr_df.Year == year) & (yr_df.Pop_Den > 1000)].values\n county250 = yr_df.FIPS[(yr_df.Year == year) & (yr_df.Pop_Den > 250) & (yr_df.Pop_Den <= 1000)].values\n county100 = yr_df.FIPS[(yr_df.Year == year) & (yr_df.Pop_Den > 100) & (yr_df.Pop_Den <= 250)].values\n county50 = yr_df.FIPS[(yr_df.Year == year) & (yr_df.Pop_Den > 50) & (yr_df.Pop_Den <= 100)].values\n county25 = yr_df.FIPS[(yr_df.Year == year) & (yr_df.Pop_Den > 25) & (yr_df.Pop_Den <= 50)].values\n county10 = yr_df.FIPS[(yr_df.Year == year) & (yr_df.Pop_Den > 10) & (yr_df.Pop_Den <= 25)].values\n countyless10 = yr_df.FIPS[yr_df.Pop_Den <= 10].values\n \n groups_dict = {}\n fips_groups = [county1k, county250, county100, county50, county25, county10, countyless10]\n groups = ['1000', '250', '100', '50', '25', '10', 'Less10']\n counter = 0\n for fips_group in fips_groups:\n fips_mort = array.array('f')\n for fips in fips_group:\n med_mort = yr_df.Med_Mort[yr_df.FIPS == fips].iloc[0]\n home_count = yr_df.Total_Owned[yr_df.FIPS == fips].iloc[0]\n fips_mort.extend(np.full(home_count, med_mort))\n groups_dict[groups[counter]] = np.median(fips_mort).round(3)\n counter += 1\n yrs_dict[year] = groups_dict\n\ndf = pd.DataFrame(yrs_dict)\ndf = df.transpose()\ndf.columns = ['More than 1000', '250 to 1000', '100 to 250', '50 to 100', '25 to 50', '10 to 25', 'Less than 10']\ndf['Year'] = list(range(2008, 2017))\ndf = df.melt(id_vars='Year', var_name='Pop', value_name='Med_Mort')\ndf.to_csv('mort_by_pop_den_5yr_0816.csv', index=False)"
] | [
[
"pandas.read_csv",
"pandas.DataFrame",
"numpy.median",
"numpy.full"
]
] |
ryu57/pyHalo | [
"61b9ab49d76f3552f5680b2e457fbd3e49b9cc89"
] | [
"pyHalo/Rendering/MassFunctions/power_law.py"
] | [
"import numpy as np\nfrom pyHalo.Rendering.MassFunctions.mass_function_utilities import integrate_power_law_analytic\nfrom pyHalo.Rendering.MassFunctions.mass_function_utilities import WDM_suppression\n\nclass GeneralPowerLaw(object):\n\n \"\"\"\n This class handles computations of a double power law mass function of the form\n dn/dm = m^x * (1 + (a * m_c / m)^b)^c\n where a, b, and c are constants, and m_c is a characteristic mass scale.\n\n The keywords for a, b, c are a_wdm, b_wdm, and c_wdm, respectively\n\n Lovell 2020 fit this mass function to simulations of Warm Dark Matter cosmologies and find\n (a, b, c) = (2.3, 0.8, -1) for central halos and (4.2, 2.5, -0.2) for subhalos\n \"\"\"\n\n def __init__(self, log_mlow, log_mhigh, power_law_index, draw_poisson, normalization,\n log_mc, a_wdm, b_wdm, c_wdm):\n\n if a_wdm is None:\n assert b_wdm is None, 'If one of a_wdm, b_wdm, or c_wdm is not specified (None), all parameters must be None'\n assert c_wdm is None, 'If one of a_wdm, b_wdm, or c_wdm is not specified (None), all parameters must be None'\n else:\n assert b_wdm is not None, 'Must specify values for all three of a_wdm, b_wdm, c_wdm'\n assert c_wdm is not None, 'Must specify values for all three of a_wdm, b_wdm, c_wdm'\n if b_wdm is None:\n assert a_wdm is None, 'If one of a_wdm, b_wdm, or c_wdm is not specified (None), all parameters must be None'\n assert c_wdm is None, 'If one of a_wdm, b_wdm, or c_wdm is not specified (None), all parameters must be None'\n else:\n assert a_wdm is not None, 'Must specify values for all three of a_wdm, b_wdm, c_wdm'\n assert c_wdm is not None, 'Must specify values for all three of a_wdm, b_wdm, c_wdm'\n if c_wdm is None:\n assert a_wdm is None, 'If one of a_wdm, b_wdm, or c_wdm is not specified (None), all parameters must be None'\n assert b_wdm is None, 'If one of a_wdm, b_wdm, or c_wdm is not specified (None), all parameters must be None'\n else:\n assert a_wdm is not None, 'Must specify values for all three of a_wdm, b_wdm, c_wdm'\n assert b_wdm is not None, 'Must specify values for all three of a_wdm, b_wdm, c_wdm'\n\n if normalization < 0:\n raise Exception('normalization cannot be < 0.')\n if c_wdm is not None and c_wdm > 0:\n raise ValueError('c_wdm should be a negative number (otherwise mass function gets steeper (unphysical)')\n if a_wdm is not None and a_wdm < 0:\n raise ValueError('a_wdm should be a positive number for suppression factor: '\n '( 1 + (a_wdm * m/m_c)^b_wdm)^c_wdm')\n\n if np.any([a_wdm is None, b_wdm is None, c_wdm is None]):\n assert log_mc is None, 'If log_mc is specified, must also specify kwargs for a_wdm, b_wdm, c_wdm.' \\\n '(See documentation in pyHalo/Rendering/MassFunctions/Powerlaw/broken_powerlaw'\n\n self._log_mc = log_mc\n self._a_wdm = a_wdm\n self._b_wdm = b_wdm\n self._c_wdm = c_wdm\n\n self.draw_poisson = draw_poisson\n self._index = power_law_index\n self._mL = 10 ** log_mlow\n self._mH = 10 ** log_mhigh\n\n self._nhalos_mean_unbroken = integrate_power_law_analytic(normalization, 10 ** log_mlow, 10 ** log_mhigh, 0,\n power_law_index)\n\n def draw(self):\n\n \"\"\"\n Draws samples from a double power law distribution between mL and mH of the form\n m ^ power_law_index * (1 + (a*mc / m)^b )^c\n\n Physically, the second term multiplying m^power_law_index can be a suppression in the mass function on small\n scales.\n\n :param draw_poisson:\n :param _index:\n :param _mH:\n :param _mL:\n :param n_draw:\n :return:\n \"\"\"\n\n m = self._sample(self.draw_poisson, self._index, self._mH, self._mL, self._nhalos_mean_unbroken)\n\n if len(m) == 0 or self._log_mc is None:\n return m\n\n factor = WDM_suppression(m, 10 ** self._log_mc, self._a_wdm, self._b_wdm, self._c_wdm)\n u = np.random.rand(int(len(m)))\n inds = np.where(u < factor)\n\n return m[inds]\n\n def _sample(self, draw_poisson, index, mH, mL, n_draw):\n\n \"\"\"\n Draws samples from a power law distribution between mL and mH\n :param draw_poisson:\n :param _index:\n :param _mH:\n :param _mL:\n :param n_draw:\n :return:\n \"\"\"\n\n if draw_poisson:\n N = np.random.poisson(n_draw)\n else:\n N = int(round(np.round(n_draw)))\n\n x = np.random.rand(N)\n if index == -1:\n norm = np.log(mH / mL)\n X = mL * np.exp(norm * x)\n else:\n X = (x * (mH ** (1 + index) - mL ** (1 + index)) + mL ** (\n 1 + index)) ** (\n (1 + index) ** -1)\n\n return np.array(X)\n"
] | [
[
"numpy.any",
"numpy.random.poisson",
"numpy.exp",
"numpy.log",
"numpy.random.rand",
"numpy.array",
"numpy.where",
"numpy.round"
]
] |
shinylin/tw-stock-collect-forecast | [
"6af2715a848336d90aaf21f8f93ed1c3568c3fa8"
] | [
"collect/TwHistory.py"
] | [
"import calendar\nimport math\nimport pandas as pd\nimport time\nimport twstock\nimport requests\nfrom datetime import datetime, timedelta\nfrom dateutil import relativedelta\nfrom db.Connection import session\nfrom enum import Enum\nfrom model.StockHistory import StockHistory\nfrom sys import float_info\nfrom talib import abstract\n\nclass HistoryType(Enum):\n DAY = (\"0\", \"日\", \"短線\")\n WEEK = (\"1\", \"週\", \"中短線\")\n MONTH = (\"2\", \"月\", \"中長線\")\n\nclass HistoryTypeTo(Enum):\n DB = 0\n HUMAN = 1\n EXPLAIN = 2\n\nclass TwHistory:\n \"\"\"TwHistory class\"\"\"\n dateFormatForTwStock = None\n dateFormat = None\n rsiDict = None\n williamsDict = None\n macdDict = None\n bbandDict = None\n \n def __init__(self):\n self.dateFormatForTwStock = \"%Y/%m/%d\"\n self.dateFormat = \"%Y-%m-%d\"\n\n def transformStrToDateTimeForTwStock(self, targetStr):\n return datetime.strptime(targetStr, self.dateFormatForTwStock)\n\n def transformStrToDateTime(self, targetStr):\n return datetime.strptime(targetStr, self.dateFormat)\n \n def transformDateTimeToStr(self, date):\n return date.strftime(self.dateFormat)\n \n def retIfNaN(self, num):\n if math.isnan(num):\n return None\n else:\n return num\n \n def createDataFrame(self, history):\n df = pd.DataFrame([h.as_simple_dict() for h in history])\n df['date'] = pd.to_datetime(df['date'])\n df.set_index('date', inplace=True)\n return df\n \n def deleteHistory(self, code, type, startDate, endDate):\n session.query(StockHistory).\\\n filter(StockHistory.code == code).\\\n filter(StockHistory.type == type).\\\n filter(StockHistory.date >= self.transformDateTimeToStr(startDate)).\\\n filter(StockHistory.date <= self.transformDateTimeToStr(endDate)).\\\n delete()\n session.commit()\n\n def calculateRSI(self, df):\n rsi = abstract.RSI(df, timeperiod=5)\n self.rsiDict = {}\n for index, number in rsi.iteritems():\n self.rsiDict[self.transformDateTimeToStr(index)] = number\n\n def calculateWilliams(self, df):\n williams = abstract.WILLR(df, timeperiod=5)\n self.williamsDict = {}\n for index, number in williams.iteritems():\n self.williamsDict[self.transformDateTimeToStr(index)] = number\n\n def calculateMACD(self, df):\n macd = abstract.MACD(df)\n self.macdDict = {}\n for index, row in macd.iterrows():\n self.macdDict[self.transformDateTimeToStr(index)] = row\n\n def calculateBBAND(self, df):\n bband = abstract.BBANDS(df, timeperiod=22)\n self.bbandDict = {}\n for index, row in bband.iterrows():\n self.bbandDict[self.transformDateTimeToStr(index)] = row\n\n def updateHistoryTechnicalIndicator(self, history):\n date = history.date\n updateFlag = False\n if history.rsi is None:\n history.rsi = self.retIfNaN(self.rsiDict[date])\n updateFlag = updateFlag or history.rsi is not None\n if history.williams is None:\n history.williams = self.retIfNaN(self.williamsDict[date])\n updateFlag = updateFlag or history.williams is not None\n if history.macd is None:\n history.macd = self.retIfNaN(self.macdDict[date].macd)\n updateFlag = updateFlag or history.macd is not None\n if history.macdsignal is None:\n history.macdsignal = self.retIfNaN(self.macdDict[date].macdsignal)\n updateFlag = updateFlag or history.macdsignal is not None\n if history.macdhist is None:\n history.macdhist = self.retIfNaN(self.macdDict[date].macdhist)\n updateFlag = updateFlag or history.macdhist is not None\n if history.upperband is None:\n history.upperband = self.retIfNaN(self.bbandDict[date].upperband)\n updateFlag = updateFlag or history.upperband is not None\n if history.middleband is None:\n history.middleband = self.retIfNaN(self.bbandDict[date].middleband)\n updateFlag = updateFlag or history.middleband is not None\n if history.lowerband is None:\n history.lowerband = self.retIfNaN(self.bbandDict[date].lowerband)\n updateFlag = updateFlag or history.lowerband is not None\n if updateFlag:\n session.merge(history)\n\n def dayHistory(self):\n for k, v in twstock.codes.items():\n if self.isStockOrETF(v.type):\n print(\"dayHistory code: \" + k)\n dayType = self.translate(HistoryType.DAY, HistoryTypeTo.DB)\n history = session.query(StockHistory).\\\n filter(StockHistory.code == k).\\\n filter(StockHistory.type == dayType).\\\n order_by(StockHistory.date.desc()).\\\n first()\n nowDate = datetime.now()\n endDateStr = self.transformDateTimeToStr(nowDate)\n startDateStr = self.transformDateTimeToStr(self.transformStrToDateTimeForTwStock(v.start)) if history is None else history.date\n\n self.finmindtrade(k, startDateStr, endDateStr, dayType)\n\n def weekHistory(self):\n today = self.transformStrToDateTime(self.transformDateTimeToStr(datetime.now()))\n weekStart = today - timedelta(days=today.weekday())\n\n for k, v in twstock.codes.items():\n if self.isStockOrETF(v.type) and self.isHistoryExist(k):\n print(\"weekHistory code: \" + k)\n latestHistoryWeek = session.query(StockHistory).\\\n filter(StockHistory.code == k).\\\n filter(StockHistory.type == self.translate(HistoryType.WEEK, HistoryTypeTo.DB)).\\\n order_by(StockHistory.date.desc()).\\\n first()\n\n startdate = self.transformStrToDateTimeForTwStock(v.start) if latestHistoryWeek is None else self.transformStrToDateTime(latestHistoryWeek.date)\n weekStartPast = startdate - timedelta(days=startdate.weekday())\n weekEndPast = weekStartPast + timedelta(days=6)\n\n while weekStartPast <= weekStart:\n self.deleteHistory(k, self.translate(HistoryType.WEEK, HistoryTypeTo.DB), weekStartPast, weekEndPast)\n historyWeek = StockHistory(code=k, type=self.translate(HistoryType.WEEK, HistoryTypeTo.DB),\n capacity=0, turnover=0, high=0, low=float_info.max, close=0)\n firstFlag = True\n for historyDay in session.query(StockHistory).\\\n filter(StockHistory.code == k).\\\n filter(StockHistory.type == self.translate(HistoryType.DAY, HistoryTypeTo.DB)).\\\n filter(StockHistory.date >= self.transformDateTimeToStr(weekStartPast)).\\\n filter(StockHistory.date <= self.transformDateTimeToStr(weekEndPast)).\\\n order_by(StockHistory.date.asc()).\\\n all():\n historyWeek.date = self.transformDateTimeToStr(weekStartPast)\n historyWeek.close = historyDay.close\n historyWeek.capacity += historyDay.capacity\n historyWeek.turnover += historyDay.turnover\n if firstFlag:\n historyWeek.open = historyDay.open\n firstFlag = False\n historyWeek.high = max(historyWeek.high, historyDay.high)\n historyWeek.low = min(historyWeek.low, historyDay.low)\n if not firstFlag:\n session.merge(historyWeek)\n weekStartPast += timedelta(days=7)\n weekEndPast += timedelta(days=7)\n\n session.commit()\n\n def monthHistory(self):\n today = self.transformStrToDateTime(self.transformDateTimeToStr(datetime.now()))\n monthStart = today.replace(day=1)\n\n for k, v in twstock.codes.items():\n if self.isStockOrETF(v.type) and self.isHistoryExist(k):\n print(\"monthHistory code: \" + k)\n latestHistoryMonth = session.query(StockHistory).\\\n filter(StockHistory.code == k).\\\n filter(StockHistory.type == self.translate(HistoryType.MONTH, HistoryTypeTo.DB)).\\\n order_by(StockHistory.date.desc()).\\\n first()\n\n startdate = self.transformStrToDateTimeForTwStock(v.start) if latestHistoryMonth is None else self.transformStrToDateTime(latestHistoryMonth.date)\n monthStartPast = startdate.replace(day=1)\n monthEndPast = monthStartPast.replace(day=calendar.monthrange(monthStartPast.year, monthStartPast.month)[1])\n\n while monthStartPast <= monthStart:\n self.deleteHistory(k, self.translate(HistoryType.MONTH, HistoryTypeTo.DB), monthStartPast, monthEndPast)\n historyMonth = StockHistory(code=k, type=self.translate(HistoryType.MONTH, HistoryTypeTo.DB),\n capacity=0, turnover=0, high=0, low=float_info.max, close=0)\n firstFlag = True\n for historyDay in session.query(StockHistory).\\\n filter(StockHistory.code == k).\\\n filter(StockHistory.type == self.translate(HistoryType.DAY, HistoryTypeTo.DB)).\\\n filter(StockHistory.date >= self.transformDateTimeToStr(monthStartPast)).\\\n filter(StockHistory.date <= self.transformDateTimeToStr(monthEndPast)).\\\n order_by(StockHistory.date.asc()).\\\n all():\n historyMonth.date = self.transformDateTimeToStr(monthStartPast)\n historyMonth.close = historyDay.close\n historyMonth.capacity += historyDay.capacity\n historyMonth.turnover += historyDay.turnover\n if firstFlag:\n historyMonth.open = historyDay.open\n firstFlag = False\n historyMonth.high = max(historyMonth.high, historyDay.high)\n historyMonth.low = min(historyMonth.low, historyDay.low)\n if not firstFlag:\n session.merge(historyMonth)\n monthStartPast = monthStartPast + relativedelta.relativedelta(months=1)\n monthEndPast = monthStartPast.replace(day=calendar.monthrange(monthStartPast.year, monthStartPast.month)[1])\n\n session.commit()\n\n def technicalIndicator(self):\n for k, v in twstock.codes.items():\n if self.isStockOrETF(v.type) and self.isHistoryExist(k):\n for historyType in HistoryType:\n print(\"technicalIndicator code: \" + k + \", type: \" + self.translate(historyType, HistoryTypeTo.HUMAN))\n historyList = session.query(StockHistory).\\\n filter(StockHistory.code == k).\\\n filter(StockHistory.type == self.translate(historyType, HistoryTypeTo.DB)).\\\n order_by(StockHistory.date.asc()).\\\n all()\n if len(historyList) == 0:\n continue\n df = self.createDataFrame(historyList)\n\n self.calculateRSI(df)\n self.calculateWilliams(df)\n self.calculateMACD(df)\n self.calculateBBAND(df)\n\n for history in historyList:\n self.updateHistoryTechnicalIndicator(history)\n session.commit()\n\n def diverge(self, highRsi, lowRsi, highWilliams, lowWilliams):\n turnoverDict = {}\n nameDict = {}\n\n for k, v in twstock.codes.items():\n if self.isStockOrETF(v.type) and self.isHistoryExist(k):\n history = session.query(StockHistory).\\\n filter(StockHistory.code == k).\\\n filter(StockHistory.type == self.translate(HistoryType.DAY, HistoryTypeTo.DB)).\\\n order_by(StockHistory.date.desc()).\\\n first()\n turnoverDict[k] = history.turnover\n nameDict[k] = v.name\n\n rankDict = {k: v for k, v in sorted(turnoverDict.items(), key=lambda item: item[1], reverse=True)}\n\n print(\"按當日成交值由大至小排名，背離條件: rsi > \" + str(highRsi) + \" or rsi < \" + str(lowRsi))\n for rankIdx, code in enumerate(rankDict.keys()):\n closePrice = None\n divergeDict = {}\n for historyType in HistoryType:\n historyTypeHuman = self.translate(historyType, HistoryTypeTo.HUMAN)\n historyTypeExplain = self.translate(historyType, HistoryTypeTo.EXPLAIN)\n historyList = session.query(StockHistory).\\\n filter(StockHistory.code == code).\\\n filter(StockHistory.type == self.translate(historyType, HistoryTypeTo.DB)).\\\n filter(StockHistory.rsi.isnot(None)).\\\n order_by(StockHistory.date.desc()).\\\n limit(self.recentHistoryLimit(historyType)).\\\n all()\n historyListLength = len(historyList)\n if historyListLength > 0:\n closePrice = historyList[0].close\n if historyListLength > 1:\n if self.isHighRsi(highRsi, historyList) and historyList[0].rsi > historyList[1].rsi and historyList[0].williams < historyList[1].williams and historyList[0].upperband is not None and historyList[0].high > historyList[0].upperband and historyList[0].close < historyList[0].open:\n divergeDict[historyTypeHuman + \" 相鄰背離 \" + historyTypeExplain + \"看空\"] = \"rsi up williams down\"\n elif self.isLowRsi(lowRsi, historyList) and historyList[0].rsi < historyList[1].rsi and historyList[0].williams > historyList[1].williams and historyList[0].lowerband is not None and historyList[0].low < historyList[0].lowerband and historyList[0].close > historyList[0].open:\n divergeDict[historyTypeHuman + \" 相鄰背離 \" + historyTypeExplain + \"看多\"] = \"rsi down williams up\"\n# if historyListLength > 2:\n# highPeak = []\n# lowPeak = []\n# for i, history in enumerate(historyList):\n# if i == 0 or i == historyListLength - 1:\n# continue\n# if len(highPeak) < 2 and historyList[i-1].rsi < history.rsi and history.rsi > historyList[i+1].rsi:\n# highPeak.append(history)\n# if len(lowPeak) < 2 and historyList[i-1].rsi > history.rsi and history.rsi < historyList[i+1].rsi:\n# lowPeak.append(history)\n# if len(highPeak) == 2 and len(lowPeak) == 2:\n# break\n# if len(highPeak) == 2 and self.isHighRsi(highRsi, highPeak):\n# if highPeak[0].rsi > highPeak[1].rsi and highPeak[0].williams < highPeak[1].williams:\n# divergeDict[historyTypeHuman + \" 波峰背離 \" + historyTypeExplain + \"看空: \" + highPeak[1].date + \" and \" + highPeak[0].date] = \"rsi up williams down\"\n# elif highPeak[0].rsi < highPeak[1].rsi and highPeak[0].williams > highPeak[1].williams and highPeak[0].williams >= highWilliams:\n# for low in lowPeak:\n# if highPeak[0].date > low.date and highPeak[1].date < low.date and low.williams <= lowWilliams:\n# divergeDict[historyTypeHuman + \" 波峰背離 反彈不過前高 \" + historyTypeExplain + \"看空: \" + highPeak[1].date + \" and \" + highPeak[0].date] = \"rsi down williams fast up\"\n# break\n# if len(lowPeak) == 2 and self.isLowRsi(lowRsi, lowPeak):\n# if lowPeak[0].rsi < lowPeak[1].rsi and lowPeak[0].williams > lowPeak[1].williams:\n# divergeDict[historyTypeHuman + \" 波谷背離 \" + historyTypeExplain + \"看多: \" + lowPeak[1].date + \" and \" + lowPeak[0].date] = \"rsi down williams up\"\n# elif lowPeak[0].rsi > lowPeak[1].rsi and lowPeak[0].williams < lowPeak[1].williams and lowPeak[0].williams <= lowWilliams:\n# for high in highPeak:\n# if lowPeak[0].date > high.date and lowPeak[1].date < high.date and high.williams >= highWilliams:\n# divergeDict[historyTypeHuman + \" 波谷背離 回測不過前低 \" + historyTypeExplain + \"看多: \" + lowPeak[1].date + \" and \" + lowPeak[0].date] = \"rsi up williams fast down\"\n# break\n\n if len(divergeDict) > 0:\n print(\"code: \" + code + \", name: \" + nameDict[code] + \", rank: \" + str(rankIdx+1) + \"/\" + str(len(rankDict)) + \", close price: \" + str(closePrice))\n for k, v in divergeDict.items():\n print(k + \" => \" + v)\n print(\"\")\n print(\"========================================================================================\")\n\n def isStockOrETF(self, type):\n return type == \"股票\" or type == \"ETF\"\n\n def isHistoryExist(self, code):\n return session.query(StockHistory).\\\n filter(StockHistory.code == code).\\\n filter(StockHistory.type == self.translate(HistoryType.DAY, HistoryTypeTo.DB)).\\\n filter(StockHistory.date == self.transformDateTimeToStr(datetime.now())).\\\n first() is not None\n\n def isHighRsi(self, highRsi, historyList):\n for i, history in enumerate(historyList):\n if i < 2 and history.rsi < highRsi:\n return False\n elif i == 2:\n break\n return True\n\n def isLowRsi(self, lowRsi, historyList):\n for i, history in enumerate(historyList):\n if i < 2 and history.rsi > lowRsi:\n return False\n elif i == 2:\n break\n return True\n\n def recentHistoryLimit(self, historyType):\n if historyType == HistoryType.DAY:\n return 40\n elif historyType == HistoryType.WEEK:\n return 16\n else:\n return 6\n\n def translate(self, historyType, historyTypeTo):\n return historyType.value[historyTypeTo.value]\n\n def finmindtrade(self, code, start, end, dayType):\n url = \"https://api.finmindtrade.com/api/v4/data\"\n parameter = {\n \"dataset\": \"TaiwanStockPrice\",\n \"data_id\": code,\n \"start_date\": start,\n \"end_date\": end,\n \"token\": \"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRlIjoiMjAyMS0wOS0yMiAxMzo0MzoyOSIsInVzZXJfaWQiOiJzaGlueWxpbiIsImlwIjoiMjEwLjY0LjE4LjIifQ.0USWMl--2LhZ9W8nyEQncyyw3Jfm-hu5xzJrNOCuEUU\"\n }\n resp = requests.get(url, params=parameter)\n json = resp.json()\n if json is not None:\n for data in resp.json()[\"data\"]:\n history = StockHistory(code=code, type=dayType, date=data[\"date\"],\n capacity=data[\"Trading_Volume\"], turnover=data[\"Trading_money\"],\n open=data[\"open\"], high=data[\"max\"], low=data[\"min\"], close=data[\"close\"])\n session.merge(history)\n session.commit()\n time.sleep(6.1)\n\ntwHistory = TwHistory()\ntwHistory.dayHistory()\ntwHistory.weekHistory()\ntwHistory.monthHistory()\ntwHistory.technicalIndicator()\ntwHistory.diverge(90, 10, -20, -80)\ntwHistory.diverge(80, 20, -20, -80)\ntwHistory.diverge(70, 30, -20, -80)"
] | [
[
"pandas.to_datetime"
]
] |
erwinvanthiel/ASL | [
"1b8846919f4bcf7bf65881faf254395cb01f8ae3"
] | [
"mlc-pgd-multi-label.py"
] | [
"import os\nimport torch\nfrom src.helper_functions.helper_functions import parse_args\nfrom src.loss_functions.losses import AsymmetricLoss, AsymmetricLossOptimized\nfrom src.models import create_model\nimport argparse\nimport matplotlib\nimport torchvision.transforms as transforms\nfrom pgd import create_targeted_adversarial_examples\n# matplotlib.use('TkAgg')\nimport matplotlib.pyplot as plt\nfrom PIL import Image\nimport numpy as np\nfrom src.helper_functions.helper_functions import mAP, CocoDetection, CocoDetectionFiltered, CutoutPIL, ModelEma, add_weight_decay\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\") # USE GPU\n\n########################## ARGUMENTS #############################################\n\nparser = argparse.ArgumentParser(description='ASL MS-COCO Inference on a single image')\n\nparser.add_argument('data', metavar='DIR', help='path to dataset', default='coco')\nparser.add_argument('--model_path', type=str, default='mlc-model-epoch50')\nparser.add_argument('--pic_path', type=str, default='./pics/test.jpg')\nparser.add_argument('--model_name', type=str, default='tresnet_m')\nparser.add_argument('--input_size', type=int, default=224)\nparser.add_argument('--dataset_type', type=str, default='MS-COCO')\n\n#IMPORTANT PARAMETER!\nparser.add_argument('--th', type=float, default=0.5)\n\n\nparser.add_argument('-b', '--batch-size', default=16, type=int,\n metavar='N', help='mini-batch size (default: 16)')\nparser.add_argument('-j', '--workers', default=8, type=int, metavar='N',\n help='number of data loading workers (default: 16)')\nargs = parse_args(parser)\n\n########################## SETUP THE MODEL AND LOAD THE DATA #####################\n\n# setup model\nprint('creating and loading the model...')\n# state = torch.load(args.model_path, map_location='cpu')\nargs.num_classes = 80\nmodel = create_model(args).cuda()\nmodel_state = torch.load(args.model_path, map_location='cpu')\nmodel.load_state_dict(model_state[\"state_dict\"])\nmodel.eval()\n\n\n# Load the data\ninstances_path = os.path.join(args.data, 'annotations/instances_train2014.json')\n# data_path_train = args.data\ndata_path = '{0}/train2014'.format(args.data)\n\n\n################ EXPERIMENT DETAILS ########################\n\nNUMBER_OF_BATCHES = 64\n# TARGET_LABELS = [0, 1, 11, 56, 78, 79]\nTARGET_LABELS = [0, 78]\nEPSILON_VALUES = [0, 0.005, 0.01, 0.02, 0.05, 0.1]\n\n########################## EXPERIMENT LOOP #####################\n\n\n\ndataset = CocoDetectionFiltered(data_path,\n instances_path,\n transforms.Compose([\n transforms.Resize((args.input_size, args.input_size)),\n transforms.ToTensor(),\n # normalize, # no need, toTensor does normalization\n ]), label_indices_positive=np.array(TARGET_LABELS))\n\n# Pytorch Data loader\ndata_loader = torch.utils.data.DataLoader(\n dataset, batch_size=args.batch_size, shuffle=True,\n num_workers=args.workers, pin_memory=True)\n\n# zero for each epsion value\nflipped_labels = np.zeros((len(EPSILON_VALUES), len(TARGET_LABELS)))\n\nfor i, (tensor_batch, labels) in enumerate(data_loader):\n tensor_batch = tensor_batch.to(device)\n\n if i >= NUMBER_OF_BATCHES:\n break;\n\n # process a batch and add the flipped labels for every epsilon\n for epsilon_index in range(len(EPSILON_VALUES)):\n\n # perform the pgd attack\n pred = torch.sigmoid(model(tensor_batch)) > args.th\n target = torch.clone(pred).detach()\n target[:, TARGET_LABELS] = 0\n adversarials = create_targeted_adversarial_examples(model, tensor_batch, target, eps=EPSILON_VALUES[epsilon_index], device=\"cuda\")\n\n # do inference again\n pred_after_attack = torch.sigmoid(model(adversarials)) > args.th\n \n # compare the attaced labels before and after the attack\n\n for _id, target_label in enumerate(TARGET_LABELS):\n flipped_labels[epsilon_index, _id] += (torch.sum(pred[:, target_label]).item() - torch.sum(pred_after_attack[:, target_label]).item())\n\n# plot and save the figures\n# plt.figure()\nfor _id, target_label in enumerate(TARGET_LABELS):\n plt.plot(EPSILON_VALUES, flipped_labels[:, _id], label='target {0}'.format(target_label))\nplt.xlabel(\"Epsilon\")\nplt.ylabel(\"Number of flipped labels\")\nplt.title(\"PGD multi-label flipdown attack\")\nplt.legend()\nplt.savefig('flipdown-pgd-multi-attack.png')\n\n\n\n\n\n\n# displaying image\n# print('showing image on screen...')\n# fig = plt.figure()\n# plt.imshow(im)\n# plt.axis('off')\n# plt.axis('tight')\n# # plt.rcParams[\"axes.titlesize\"] = 10\n# plt.title(\"detected classes: {}\".format(detected_classes))\n\n# plt.show()\n# print('done\\n')"
] | [
[
"torch.sum",
"torch.utils.data.DataLoader",
"matplotlib.pyplot.legend",
"torch.load",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.title",
"torch.cuda.is_available",
"matplotlib.pyplot.ylabel",
"numpy.array",
"torch.clone",
"matplotlib.pyplot.xlabel"
]
] |
ZERO2ER0/OpticalNN | [
"56e34a02d9855951fc3a28d0bfddcdbad85a0c90"
] | [
"onn/onn.py"
] | [
"\"\"\"\nreplace first layer of AlexNet with optical setup\nAdapted other layers of AlexNet code from AlexNet.py, code written by Frederik Kratzert at\nhttps://kratzert.github.io/2017/02/24/finetuning-alexnet-with-tensorflow.html\n\"\"\"\nimport tensorflow as tf\nimport numpy as np\nIterator = tf.data.Iterator\n\n\n# xx, yy, Lambda, k_z_values can all be generated from onn_setup.ipynb.\nxx = np.load('xx.npy')\nyy = np.load('yy.npy')\nLambda = np.load('Lambda.npy')\nk_z_values = np.load('k_z_values.npy')\nx_tensor = tf.constant(xx, tf.float32)\ny_tensor = tf.constant(yy, tf.float32)\nLambda_tensor = tf.constant(Lambda, tf.float32)\nk_z = tf.constant(k_z_values, tf.complex64)\nf = tf.constant(0.3E-2)\n\n\ndef fftshift_tf(data):\n \"\"\"\n :param data: input tensor to do fftshift\n :return: after fftshift\n \"\"\"\n dims = tf.shape(data)\n num = dims[3]\n shift_amt = (num - 1) / 2\n shift_amt = tf.cast(shift_amt, np.int32)\n output = tf.manip.roll(data, shift=shift_amt, axis=2)\n output = tf.manip.roll(output, shift=shift_amt, axis=3)\n\n return output\n\n\ndef ifftshift_tf(data):\n \"\"\"\n Performs an ifftshift operation on the last two dimensions of a 4-D input tensor\n :param data: input tensor to do ifftshift\n :return: after ifftshift\n \"\"\"\n dims = tf.shape(data)\n num = dims[3]\n shift_amt = (num + 1) / 2\n shift_amt = tf.cast(shift_amt, np.int32)\n output = tf.manip.roll(data, shift=shift_amt, axis=2)\n output = tf.manip.roll(output, shift=shift_amt, axis=3)\n\n return output\n\n\ndef generate_phase():\n \"\"\"\n Generates the phase for a lens based on the focal length variable \"f\".\n Other referenced variables are global\n :return: phase generated\n \"\"\"\n phase = tf.constant(2 * np.pi, tf.float32)\\\n / Lambda * (tf.sqrt(tf.square(x_tensor) + tf.square(y_tensor) + tf.square(f)) - f)\n phase = tf.cast(phase, tf.complex64)\n return phase\n\n\ndef generate_propagator():\n \"\"\"\n Generates the Fourier space propagator based on the focal length variable \"f\".\n Other referenced variables are global\n :return: propagator generated\n \"\"\"\n propagator = tf.exp(1j * k_z * tf.cast(f, tf.complex64))\n propagator = ifftshift_tf(propagator)\n\n return propagator\n\n\ndef propagate(input_field, propagator):\n \"\"\"\n Propagate an input E-field distribution along the optical axis using the defined propagator\n :param input_field: input field for doing propagation\n :param propagator: generated propagator\n :return: result after propagation\n \"\"\"\n output = tf.ifft2d(tf.fft2d(input_field) * propagator)\n\n return output\n\n\ndef simulate_4f_system(input_field, kernel):\n \"\"\"\n Pass an image through a 4f system\n :param input_field: input field of our 4f system\n :param kernel: kernel for doing convolution\n :return: output of our 4f system\n \"\"\"\n # Calculate the lens phase\n lens_phase = generate_phase()\n\n # Calculate the propagator\n propagator = generate_propagator()\n\n # Propagate up to the first lens\n before_l1 = propagate(input_field, propagator)\n\n # Apply lens1 and propagate to the filter plane\n before_kernel = propagate(before_l1 * tf.keras.backend.exp(-1j * lens_phase), propagator)\n\n # Apply kernel and propagate to the second lens\n before_l2 = propagate(before_kernel * kernel, propagator)\n\n # Apply lens2 and propagate to the output plane\n output = propagate(before_l2 * tf.keras.backend.exp(-1j * lens_phase), propagator)\n\n # Return output of the 4f optical convolution\n return output\n\n\ndef convolve_with_all_kernels(image, batch_size, name):\n \"\"\"\n doing convolution with all kernels in frequency domain\n :param image: input image\n :param kernel_in: kernel for doing convolution\n :param name: scope name\n :return: result after doing convolution with all kernels\n \"\"\"\n with tf.variable_scope(name) as scope:\n kernel = tf.get_variable(name='weights', trainable=True,\n shape=[11, 11, 3, 96])\n # f = tf.get_variable(name ='f', initializer=0.3E-2, trainable=True)\n # Zero pad the kernels for subsequent Fourier processing\n kernels = tf.concat([kernel, tf.constant(np.zeros((11, 216, 3, 96)), tf.float32)], axis=1)\n kernels = tf.concat([kernels, tf.constant(np.zeros((216, 227, 3, 96)), tf.float32)], axis=0)\n\n # Align the kernels for Fourier transforming\n kernels = tf.transpose(kernels, perm=[3, 2, 0, 1])\n kernels = tf.cast(kernels, tf.complex64)\n kernels = tf.fft2d(kernels)\n kernels = ifftshift_tf(kernels)\n\n # Add an extra dimension for the batch size and duplicate\n # the kernels to apply equally to all images in the batch\n kernels = tf.expand_dims(kernels, axis=0)\n kernels = tf.tile(kernels, multiples=[batch_size, 1, 1, 1, 1])\n\n # Add a dimension to the input image tensor to\n # enable convolution with all 96 first layer kernels\n image = tf.cast(image, tf.complex64)\n image = tf.expand_dims(image, axis=1)\n image = tf.transpose(image, perm=[0, 1, 4, 2, 3])\n image = tf.tile(image, multiples=[1, 96, 1, 1, 1])\n\n # Simulate the 4f system output for all 96 kernels\n # for all color channels and sum the channel outputs\n output = tf.reduce_sum(tf.abs(simulate_4f_system(image, kernels)) ** 2, axis=2)\n\n # Transpose and flip the output for display purposes\n output = tf.transpose(output, perm=[0, 2, 3, 1])\n output = tf.image.flip_left_right(output)\n output = tf.image.flip_up_down(output)\n\n # Convert to float format\n output = tf.cast(output, tf.float32)\n\n # Return the output\n return output\n\n\nclass ONN(object):\n \"\"\"Implementation of ONN based on AlexNet implementation.\"\"\"\n\n def __init__(self, x, batch_size, keep_prob, num_classes, skip_layer, weights_path='DEFAULT'):\n \"\"\"Create the graph of the ONN model.\n\n Args:\n x: Placeholder for the input tensor.\n batch_size: batch_size for training\n keep_prob: Dropout probability.\n num_classes: Number of classes in the dataset.\n skip_layer: List of names of the layer, that get trained from\n scratch\n weights_path: Complete path to the pretrained weight file, if it\n isn't in the same folder as this code\n \"\"\"\n # Parse input arguments into class variables\n self.X = x\n self.NUM_CLASSES = num_classes\n self.BATCH_SIZE = batch_size\n self.SKIP_LAYER = skip_layer\n self.KEEP_PROB = keep_prob\n if weights_path == 'DEFAULT':\n self.WEIGHTS_PATH = 'kernel_alexnet.npy'\n else:\n self.WEIGHTS_PATH = weights_path\n\n # Call the create function to build the computational graph of AlexNet\n self.create()\n\n def create(self):\n \"\"\"Create the network graph.\"\"\"\n # 1st Layer: OP-conv\n conv1 = convolve_with_all_kernels(self.X, self.BATCH_SIZE, 'op')\n norm1 = lrn(conv1, 2, 1e-05, 0.75, name='norm1')\n pool1 = max_pool(norm1, 3, 3, 2, 2, padding='VALID', name='pool1')\n\n # 2nd Layer: Conv (w ReLu) -> Lrn -> Pool with 2 groups\n conv2 = conv(pool1, 5, 5, 256, 1, 1, groups=2, name='conv2')\n norm2 = lrn(conv2, 2, 1e-05, 0.75, name='norm2')\n pool2 = max_pool(norm2, 3, 3, 2, 2, padding='VALID', name='pool2')\n\n # 3rd Layer: Conv (w ReLu)\n conv3 = conv(pool2, 3, 3, 384, 1, 1, name='conv3')\n\n # 4th Layer: Conv (w ReLu) splitted into two groups\n conv4 = conv(conv3, 3, 3, 384, 1, 1, groups=2, name='conv4')\n\n # 5th Layer: Conv (w ReLu) -> Pool splitted into two groups\n conv5 = conv(conv4, 3, 3, 256, 1, 1, groups=2, name='conv5')\n pool5 = max_pool(conv5, 3, 3, 2, 2, padding='VALID', name='pool5')\n\n # 6th Layer: Flatten -> FC (w ReLu) -> Dropout\n flattened = tf.reshape(pool5, [-1, 27 * 27 * 256])\n fc6 = fc(flattened, 27 * 27 * 256, 4096, name='fc6')\n dropout6 = dropout(fc6, self.KEEP_PROB)\n\n # 7th Layer: FC (w ReLu) -> Dropout\n fc7 = fc(dropout6, 4096, 4096, name='fc7')\n dropout7 = dropout(fc7, self.KEEP_PROB)\n\n # 8th Layer: FC and return unscaled activations\n self.fc8 = fc(dropout7, 4096, self.NUM_CLASSES, relu=False, name='fc8')\n\n def load_initial_weights(self, session):\n \"\"\"\n load pre-trained kernel from first layer of AlexNet\n \"\"\"\n # Load the weights into memory\n kernel_pretrained = np.load(self.WEIGHTS_PATH, encoding='bytes')\n with tf.variable_scope('op', reuse=True):\n # Assign kernel to its corresponding tf variable\n var = tf.get_variable('weights', trainable=False)\n session.run(var.assign(kernel_pretrained))\n\n\ndef conv(x, filter_height, filter_width, num_filters, stride_y, stride_x, name,\n padding='SAME', groups=1):\n \"\"\"Create a convolution layer.\n Adapted from: https://github.com/ethereon/caffe-tensorflow\n \"\"\"\n # Get number of input channels\n input_channels = int(x.get_shape()[-1])\n\n # Create lambda function for the convolution\n convolve = lambda i, k: tf.nn.conv2d(i, k,\n strides=[1, stride_y, stride_x, 1],\n padding=padding)\n\n with tf.variable_scope(name) as scope:\n # Create tf variables for the weights and biases of the conv layer\n weights = tf.get_variable('weights', trainable=True, shape=[filter_height,\n filter_width,\n input_channels / groups,\n num_filters])\n biases = tf.get_variable('biases', trainable=True, shape=[num_filters])\n\n if groups == 1:\n conv = convolve(x, weights)\n\n # In the cases of multiple groups, split inputs & weights and\n else:\n # Split input and weights and convolve them separately\n input_groups = tf.split(axis=3, num_or_size_splits=groups, value=x)\n weight_groups = tf.split(axis=3, num_or_size_splits=groups,\n value=weights)\n output_groups = [convolve(i, k) for i, k in zip(input_groups, weight_groups)]\n\n # Concat the convolved output together again\n conv = tf.concat(axis=3, values=output_groups)\n\n # Add biases\n bias = tf.reshape(tf.nn.bias_add(conv, biases), tf.shape(conv))\n\n # Apply relu function\n relu = tf.nn.relu(bias, name=scope.name)\n\n return relu\n\n\ndef fc(x, num_in, num_out, name, relu=True):\n \"\"\"Create a fully connected layer.\"\"\"\n with tf.variable_scope(name) as scope:\n\n # Create tf variables for the weights and biases\n weights = tf.get_variable('weights', shape=[num_in, num_out], trainable=True)\n biases = tf.get_variable('biases', shape=[num_out], trainable=True)\n\n # Matrix multiply weights and inputs and add bias\n act = tf.nn.xw_plus_b(x, weights, biases, name=scope.name)\n\n if relu:\n # Apply ReLu non linearity\n relu = tf.nn.relu(act)\n return relu\n else:\n return act\n\n\ndef max_pool(x, filter_height, filter_width, stride_y, stride_x, name,\n padding='SAME'):\n \"\"\"Create a max pooling layer.\"\"\"\n return tf.nn.max_pool(x, ksize=[1, filter_height, filter_width, 1],\n strides=[1, stride_y, stride_x, 1],\n padding=padding, name=name)\n\n\ndef lrn(x, radius, alpha, beta, name, bias=1.0):\n \"\"\"Create a local response normalization layer.\"\"\"\n return tf.nn.local_response_normalization(x, depth_radius=radius,\n alpha=alpha, beta=beta,\n bias=bias, name=name)\n\n\ndef dropout(x, keep_prob):\n \"\"\"Create a dropout layer.\"\"\"\n return tf.nn.dropout(x, keep_prob)\n"
] | [
[
"tensorflow.reshape",
"tensorflow.image.flip_left_right",
"tensorflow.variable_scope",
"tensorflow.concat",
"tensorflow.split",
"tensorflow.image.flip_up_down",
"tensorflow.nn.dropout",
"tensorflow.nn.max_pool",
"tensorflow.constant",
"tensorflow.transpose",
"numpy.load",
"tensorflow.shape",
"numpy.zeros",
"tensorflow.fft2d",
"tensorflow.expand_dims",
"tensorflow.cast",
"tensorflow.manip.roll",
"tensorflow.nn.xw_plus_b",
"tensorflow.tile",
"tensorflow.nn.local_response_normalization",
"tensorflow.nn.bias_add",
"tensorflow.keras.backend.exp",
"tensorflow.nn.conv2d",
"tensorflow.square",
"tensorflow.nn.relu",
"tensorflow.get_variable"
]
] |
naviocean/imgclsmob | [
"f2993d3ce73a2f7ddba05da3891defb08547d504",
"f2993d3ce73a2f7ddba05da3891defb08547d504",
"f2993d3ce73a2f7ddba05da3891defb08547d504",
"f2993d3ce73a2f7ddba05da3891defb08547d504",
"f2993d3ce73a2f7ddba05da3891defb08547d504"
] | [
"gluon/gluoncv2/models/fdmobilenet.py",
"train_pt.py",
"train_ke.py",
"chainer_/chainercv2/models/seresnet_cifar.py",
"tensorflow2/tf2cv/models/inceptionresnetv1.py"
] | [
"\"\"\"\n FD-MobileNet for ImageNet-1K, implemented in Gluon.\n Original paper: 'FD-MobileNet: Improved MobileNet with A Fast Downsampling Strategy,'\n https://arxiv.org/abs/1802.03750.\n\"\"\"\n\n__all__ = ['fdmobilenet_w1', 'fdmobilenet_w3d4', 'fdmobilenet_wd2', 'fdmobilenet_wd4', 'get_fdmobilenet']\n\nimport os\nfrom mxnet import cpu\nfrom .mobilenet import MobileNet\n\n\ndef get_fdmobilenet(width_scale,\n model_name=None,\n pretrained=False,\n ctx=cpu(),\n root=os.path.join(\"~\", \".mxnet\", \"models\"),\n **kwargs):\n \"\"\"\n Create FD-MobileNet model with specific parameters.\n\n Parameters:\n ----------\n width_scale : float\n Scale factor for width of layers.\n model_name : str or None, default None\n Model name for loading pretrained model.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n ctx : Context, default CPU\n The context in which to load the pretrained weights.\n root : str, default '~/.mxnet/models'\n Location for keeping the model parameters.\n \"\"\"\n channels = [[32], [64], [128, 128], [256, 256], [512, 512, 512, 512, 512, 1024]]\n first_stage_stride = True\n\n if width_scale != 1.0:\n channels = [[int(cij * width_scale) for cij in ci] for ci in channels]\n\n net = MobileNet(\n channels=channels,\n first_stage_stride=first_stage_stride,\n **kwargs)\n\n if pretrained:\n if (model_name is None) or (not model_name):\n raise ValueError(\"Parameter `model_name` should be properly initialized for loading pretrained model.\")\n from .model_store import get_model_file\n net.load_parameters(\n filename=get_model_file(\n model_name=model_name,\n local_model_store_dir_path=root),\n ctx=ctx)\n\n return net\n\n\ndef fdmobilenet_w1(**kwargs):\n \"\"\"\n FD-MobileNet 1.0x model from 'FD-MobileNet: Improved MobileNet with A Fast Downsampling Strategy,'\n https://arxiv.org/abs/1802.03750.\n\n Parameters:\n ----------\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n ctx : Context, default CPU\n The context in which to load the pretrained weights.\n root : str, default '~/.mxnet/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_fdmobilenet(width_scale=1.0, model_name=\"fdmobilenet_w1\", **kwargs)\n\n\ndef fdmobilenet_w3d4(**kwargs):\n \"\"\"\n FD-MobileNet 0.75x model from 'FD-MobileNet: Improved MobileNet with A Fast Downsampling Strategy,'\n https://arxiv.org/abs/1802.03750.\n\n Parameters:\n ----------\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n ctx : Context, default CPU\n The context in which to load the pretrained weights.\n root : str, default '~/.mxnet/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_fdmobilenet(width_scale=0.75, model_name=\"fdmobilenet_w3d4\", **kwargs)\n\n\ndef fdmobilenet_wd2(**kwargs):\n \"\"\"\n FD-MobileNet 0.5x model from 'FD-MobileNet: Improved MobileNet with A Fast Downsampling Strategy,'\n https://arxiv.org/abs/1802.03750.\n\n Parameters:\n ----------\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n ctx : Context, default CPU\n The context in which to load the pretrained weights.\n root : str, default '~/.mxnet/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_fdmobilenet(width_scale=0.5, model_name=\"fdmobilenet_wd2\", **kwargs)\n\n\ndef fdmobilenet_wd4(**kwargs):\n \"\"\"\n FD-MobileNet 0.25x model from 'FD-MobileNet: Improved MobileNet with A Fast Downsampling Strategy,'\n https://arxiv.org/abs/1802.03750.\n\n Parameters:\n ----------\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n ctx : Context, default CPU\n The context in which to load the pretrained weights.\n root : str, default '~/.mxnet/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_fdmobilenet(width_scale=0.25, model_name=\"fdmobilenet_wd4\", **kwargs)\n\n\ndef _test():\n import numpy as np\n import mxnet as mx\n\n pretrained = False\n\n models = [\n fdmobilenet_w1,\n fdmobilenet_w3d4,\n fdmobilenet_wd2,\n fdmobilenet_wd4,\n ]\n\n for model in models:\n\n net = model(pretrained=pretrained)\n\n ctx = mx.cpu()\n if not pretrained:\n net.initialize(ctx=ctx)\n\n net_params = net.collect_params()\n weight_count = 0\n for param in net_params.values():\n if (param.shape is None) or (not param._differentiable):\n continue\n weight_count += np.prod(param.shape)\n print(\"m={}, {}\".format(model.__name__, weight_count))\n assert (model != fdmobilenet_w1 or weight_count == 2901288)\n assert (model != fdmobilenet_w3d4 or weight_count == 1833304)\n assert (model != fdmobilenet_wd2 or weight_count == 993928)\n assert (model != fdmobilenet_wd4 or weight_count == 383160)\n\n x = mx.nd.zeros((1, 3, 224, 224), ctx=ctx)\n y = net(x)\n assert (y.shape == (1, 1000))\n\n\nif __name__ == \"__main__\":\n _test()\n",
"\"\"\"\r\n Script for training model on PyTorch.\r\n\"\"\"\r\n\r\nimport os\r\nimport time\r\nimport logging\r\nimport argparse\r\nimport random\r\nimport numpy as np\r\n\r\nimport torch.nn as nn\r\nimport torch.backends.cudnn as cudnn\r\nimport torch.utils.data\r\n\r\nfrom common.logger_utils import initialize_logging\r\nfrom common.train_log_param_saver import TrainLogParamSaver\r\nfrom pytorch.utils import prepare_pt_context, prepare_model, validate\r\nfrom pytorch.utils import report_accuracy, get_composite_metric, get_metric_name\r\n\r\nfrom pytorch.dataset_utils import get_dataset_metainfo\r\nfrom pytorch.dataset_utils import get_train_data_source, get_val_data_source\r\n\r\n\r\ndef add_train_cls_parser_arguments(parser):\r\n \"\"\"\r\n Create python script parameters (for training/classification specific subpart).\r\n\r\n Parameters:\r\n ----------\r\n parser : ArgumentParser\r\n ArgumentParser instance.\r\n \"\"\"\r\n parser.add_argument(\r\n \"--model\",\r\n type=str,\r\n required=True,\r\n help=\"type of model to use. see model_provider for options\")\r\n parser.add_argument(\r\n \"--use-pretrained\",\r\n action=\"store_true\",\r\n help=\"enable using pretrained model from github repo\")\r\n parser.add_argument(\r\n \"--resume\",\r\n type=str,\r\n default=\"\",\r\n help=\"resume from previously saved parameters if not None\")\r\n parser.add_argument(\r\n \"--resume-state\",\r\n type=str,\r\n default=\"\",\r\n help=\"resume from previously saved optimizer state if not None\")\r\n\r\n parser.add_argument(\r\n \"--num-gpus\",\r\n type=int,\r\n default=0,\r\n help=\"number of gpus to use\")\r\n parser.add_argument(\r\n \"-j\",\r\n \"--num-data-workers\",\r\n dest=\"num_workers\",\r\n default=4,\r\n type=int,\r\n help=\"number of preprocessing workers\")\r\n\r\n parser.add_argument(\r\n \"--batch-size\",\r\n type=int,\r\n default=512,\r\n help=\"training batch size per device (CPU/GPU)\")\r\n parser.add_argument(\r\n \"--batch-size-scale\",\r\n type=int,\r\n default=1,\r\n help=\"manual batch-size increasing factor\")\r\n parser.add_argument(\r\n \"--num-epochs\",\r\n type=int,\r\n default=120,\r\n help=\"number of training epochs\")\r\n parser.add_argument(\r\n \"--start-epoch\",\r\n type=int,\r\n default=1,\r\n help=\"starting epoch for resuming, default is 1 for new training\")\r\n parser.add_argument(\r\n \"--attempt\",\r\n type=int,\r\n default=1,\r\n help=\"current attempt number for training\")\r\n\r\n parser.add_argument(\r\n \"--optimizer-name\",\r\n type=str,\r\n default=\"nag\",\r\n help=\"optimizer name\")\r\n parser.add_argument(\r\n \"--lr\",\r\n type=float,\r\n default=0.1,\r\n help=\"learning rate\")\r\n parser.add_argument(\r\n \"--lr-mode\",\r\n type=str,\r\n default=\"cosine\",\r\n help=\"learning rate scheduler mode. options are step, poly and cosine\")\r\n parser.add_argument(\r\n \"--lr-decay\",\r\n type=float,\r\n default=0.1,\r\n help=\"decay rate of learning rate\")\r\n parser.add_argument(\r\n \"--lr-decay-period\",\r\n type=int,\r\n default=0,\r\n help=\"interval for periodic learning rate decays. default is 0 to disable\")\r\n parser.add_argument(\r\n \"--lr-decay-epoch\",\r\n type=str,\r\n default=\"40,60\",\r\n help=\"epoches at which learning rate decays\")\r\n parser.add_argument(\r\n \"--target-lr\",\r\n type=float,\r\n default=1e-8,\r\n help=\"ending learning rate\")\r\n parser.add_argument(\r\n \"--poly-power\",\r\n type=float,\r\n default=2,\r\n help=\"power value for poly LR scheduler\")\r\n parser.add_argument(\r\n \"--warmup-epochs\",\r\n type=int,\r\n default=0,\r\n help=\"number of warmup epochs\")\r\n parser.add_argument(\r\n \"--warmup-lr\",\r\n type=float,\r\n default=1e-8,\r\n help=\"starting warmup learning rate\")\r\n parser.add_argument(\r\n \"--warmup-mode\",\r\n type=str,\r\n default=\"linear\",\r\n help=\"learning rate scheduler warmup mode. options are linear, poly and constant\")\r\n parser.add_argument(\r\n \"--momentum\",\r\n type=float,\r\n default=0.9,\r\n help=\"momentum value for optimizer\")\r\n parser.add_argument(\r\n \"--wd\",\r\n type=float,\r\n default=0.0001,\r\n help=\"weight decay rate\")\r\n parser.add_argument(\r\n \"--gamma-wd-mult\",\r\n type=float,\r\n default=1.0,\r\n help=\"weight decay multiplier for batchnorm gamma\")\r\n parser.add_argument(\r\n \"--beta-wd-mult\",\r\n type=float,\r\n default=1.0,\r\n help=\"weight decay multiplier for batchnorm beta\")\r\n parser.add_argument(\r\n \"--bias-wd-mult\",\r\n type=float,\r\n default=1.0,\r\n help=\"weight decay multiplier for bias\")\r\n parser.add_argument(\r\n \"--grad-clip\",\r\n type=float,\r\n default=None,\r\n help=\"max_norm for gradient clipping\")\r\n parser.add_argument(\r\n \"--label-smoothing\",\r\n action=\"store_true\",\r\n help=\"use label smoothing\")\r\n\r\n parser.add_argument(\r\n \"--mixup\",\r\n action=\"store_true\",\r\n help=\"use mixup strategy\")\r\n parser.add_argument(\r\n \"--mixup-epoch-tail\",\r\n type=int,\r\n default=15,\r\n help=\"number of epochs without mixup at the end of training\")\r\n\r\n parser.add_argument(\r\n \"--log-interval\",\r\n type=int,\r\n default=50,\r\n help=\"number of batches to wait before logging\")\r\n parser.add_argument(\r\n \"--save-interval\",\r\n type=int,\r\n default=4,\r\n help=\"saving parameters epoch interval, best model will always be saved\")\r\n parser.add_argument(\r\n \"--save-dir\",\r\n type=str,\r\n default=\"\",\r\n help=\"directory of saved models and log-files\")\r\n parser.add_argument(\r\n \"--logging-file-name\",\r\n type=str,\r\n default=\"train.log\",\r\n help=\"filename of training log\")\r\n\r\n parser.add_argument(\r\n \"--seed\",\r\n type=int,\r\n default=-1,\r\n help=\"Random seed to be fixed\")\r\n parser.add_argument(\r\n \"--log-packages\",\r\n type=str,\r\n default=\"torch, torchvision\",\r\n help=\"list of python packages for logging\")\r\n parser.add_argument(\r\n \"--log-pip-packages\",\r\n type=str,\r\n default=\"\",\r\n help=\"list of pip packages for logging\")\r\n\r\n parser.add_argument(\r\n \"--tune-layers\",\r\n type=str,\r\n default=\"\",\r\n help=\"regexp for selecting layers for fine tuning\")\r\n\r\n\r\ndef parse_args():\r\n \"\"\"\r\n Parse python script parameters (common part).\r\n\r\n Returns:\r\n -------\r\n ArgumentParser\r\n Resulted args.\r\n \"\"\"\r\n parser = argparse.ArgumentParser(\r\n description=\"Train a model for image classification (PyTorch)\",\r\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\r\n parser.add_argument(\r\n \"--dataset\",\r\n type=str,\r\n default=\"ImageNet1K\",\r\n help=\"dataset name. options are ImageNet1K, CUB200_2011, CIFAR10, CIFAR100, SVHN\")\r\n parser.add_argument(\r\n \"--work-dir\",\r\n type=str,\r\n default=os.path.join(\"..\", \"imgclsmob_data\"),\r\n help=\"path to working directory only for dataset root path preset\")\r\n\r\n args, _ = parser.parse_known_args()\r\n dataset_metainfo = get_dataset_metainfo(dataset_name=args.dataset)\r\n dataset_metainfo.add_dataset_parser_arguments(\r\n parser=parser,\r\n work_dir_path=args.work_dir)\r\n\r\n add_train_cls_parser_arguments(parser)\r\n\r\n args = parser.parse_args()\r\n return args\r\n\r\n\r\ndef init_rand(seed):\r\n \"\"\"\r\n Initialize all random generators by seed.\r\n\r\n Parameters:\r\n ----------\r\n seed : int\r\n Seed value.\r\n\r\n Returns:\r\n -------\r\n int\r\n Generated seed value.\r\n \"\"\"\r\n if seed <= 0:\r\n seed = np.random.randint(10000)\r\n else:\r\n cudnn.deterministic = True\r\n logging.warning(\r\n \"You have chosen to seed training. This will turn on the CUDNN deterministic setting, which can slow down \"\r\n \"your training considerably! You may see unexpected behavior when restarting from checkpoints.\")\r\n random.seed(seed)\r\n np.random.seed(seed)\r\n torch.manual_seed(seed)\r\n return seed\r\n\r\n\r\ndef prepare_trainer(net,\r\n optimizer_name,\r\n wd,\r\n momentum,\r\n lr_mode,\r\n lr,\r\n lr_decay_period,\r\n lr_decay_epoch,\r\n lr_decay,\r\n num_epochs,\r\n state_file_path):\r\n \"\"\"\r\n Prepare trainer.\r\n\r\n Parameters:\r\n ----------\r\n net : Module\r\n Model.\r\n optimizer_name : str\r\n Name of optimizer.\r\n wd : float\r\n Weight decay rate.\r\n momentum : float\r\n Momentum value.\r\n lr_mode : str\r\n Learning rate scheduler mode.\r\n lr : float\r\n Learning rate.\r\n lr_decay_period : int\r\n Interval for periodic learning rate decays.\r\n lr_decay_epoch : str\r\n Epoches at which learning rate decays.\r\n lr_decay : float\r\n Decay rate of learning rate.\r\n num_epochs : int\r\n Number of training epochs.\r\n state_file_path : str\r\n Path for file with trainer state.\r\n\r\n Returns:\r\n -------\r\n Optimizer\r\n Optimizer.\r\n LRScheduler\r\n Learning rate scheduler.\r\n int\r\n Start epoch.\r\n \"\"\"\r\n optimizer_name = optimizer_name.lower()\r\n if (optimizer_name == \"sgd\") or (optimizer_name == \"nag\"):\r\n optimizer = torch.optim.SGD(\r\n params=net.parameters(),\r\n lr=lr,\r\n momentum=momentum,\r\n weight_decay=wd,\r\n nesterov=(optimizer_name == \"nag\"))\r\n else:\r\n raise ValueError(\"Usupported optimizer: {}\".format(optimizer_name))\r\n\r\n if state_file_path:\r\n checkpoint = torch.load(state_file_path)\r\n if type(checkpoint) == dict:\r\n optimizer.load_state_dict(checkpoint[\"optimizer\"])\r\n start_epoch = checkpoint[\"epoch\"]\r\n else:\r\n start_epoch = None\r\n else:\r\n start_epoch = None\r\n\r\n cudnn.benchmark = True\r\n\r\n lr_mode = lr_mode.lower()\r\n if lr_decay_period > 0:\r\n lr_decay_epoch = list(range(lr_decay_period, num_epochs, lr_decay_period))\r\n else:\r\n lr_decay_epoch = [int(i) for i in lr_decay_epoch.split(\",\")]\r\n if (lr_mode == \"step\") and (lr_decay_period != 0):\r\n lr_scheduler = torch.optim.lr_scheduler.StepLR(\r\n optimizer=optimizer,\r\n step_size=lr_decay_period,\r\n gamma=lr_decay,\r\n last_epoch=-1)\r\n elif (lr_mode == \"multistep\") or ((lr_mode == \"step\") and (lr_decay_period == 0)):\r\n lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(\r\n optimizer=optimizer,\r\n milestones=lr_decay_epoch,\r\n gamma=lr_decay,\r\n last_epoch=-1)\r\n elif lr_mode == \"cosine\":\r\n for group in optimizer.param_groups:\r\n group.setdefault(\"initial_lr\", group[\"lr\"])\r\n lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(\r\n optimizer=optimizer,\r\n T_max=num_epochs,\r\n last_epoch=(num_epochs - 1))\r\n else:\r\n raise ValueError(\"Usupported lr_scheduler: {}\".format(lr_mode))\r\n\r\n return optimizer, lr_scheduler, start_epoch\r\n\r\n\r\ndef save_params(file_stem,\r\n state):\r\n \"\"\"\r\n Save current model/trainer parameters.\r\n\r\n Parameters:\r\n ----------\r\n file_stem : str\r\n File stem (with path).\r\n state : dict\r\n Whole state of model & trainer.\r\n trainer : Trainer\r\n Trainer.\r\n \"\"\"\r\n torch.save(\r\n obj=state[\"state_dict\"],\r\n f=(file_stem + \".pth\"))\r\n torch.save(\r\n obj=state,\r\n f=(file_stem + \".states\"))\r\n\r\n\r\ndef train_epoch(epoch,\r\n net,\r\n train_metric,\r\n train_data,\r\n use_cuda,\r\n L,\r\n optimizer,\r\n # lr_scheduler,\r\n batch_size,\r\n log_interval):\r\n \"\"\"\r\n Train model on particular epoch.\r\n\r\n Parameters:\r\n ----------\r\n epoch : int\r\n Epoch number.\r\n net : Module\r\n Model.\r\n train_metric : EvalMetric\r\n Metric object instance.\r\n train_data : DataLoader\r\n Data loader.\r\n use_cuda : bool\r\n Whether to use CUDA.\r\n L : Loss\r\n Loss function.\r\n optimizer : Optimizer\r\n Optimizer.\r\n batch_size : int\r\n Training batch size.\r\n log_interval : int\r\n Batch count period for logging.\r\n\r\n Returns:\r\n -------\r\n float\r\n Loss value.\r\n \"\"\"\r\n tic = time.time()\r\n net.train()\r\n train_metric.reset()\r\n train_loss = 0.0\r\n\r\n btic = time.time()\r\n for i, (data, target) in enumerate(train_data):\r\n if use_cuda:\r\n data = data.cuda(non_blocking=True)\r\n target = target.cuda(non_blocking=True)\r\n output = net(data)\r\n loss = L(output, target)\r\n optimizer.zero_grad()\r\n loss.backward()\r\n optimizer.step()\r\n\r\n train_loss += loss.item()\r\n\r\n train_metric.update(\r\n labels=target,\r\n preds=output)\r\n\r\n if log_interval and not (i + 1) % log_interval:\r\n speed = batch_size * log_interval / (time.time() - btic)\r\n btic = time.time()\r\n train_accuracy_msg = report_accuracy(metric=train_metric)\r\n logging.info(\"Epoch[{}] Batch [{}]\\tSpeed: {:.2f} samples/sec\\t{}\\tlr={:.5f}\".format(\r\n epoch + 1, i, speed, train_accuracy_msg, optimizer.param_groups[0][\"lr\"]))\r\n\r\n throughput = int(batch_size * (i + 1) / (time.time() - tic))\r\n logging.info(\"[Epoch {}] speed: {:.2f} samples/sec\\ttime cost: {:.2f} sec\".format(\r\n epoch + 1, throughput, time.time() - tic))\r\n\r\n train_loss /= (i + 1)\r\n train_accuracy_msg = report_accuracy(metric=train_metric)\r\n logging.info(\"[Epoch {}] training: {}\\tloss={:.4f}\".format(\r\n epoch + 1, train_accuracy_msg, train_loss))\r\n\r\n return train_loss\r\n\r\n\r\ndef train_net(batch_size,\r\n num_epochs,\r\n start_epoch1,\r\n train_data,\r\n val_data,\r\n net,\r\n optimizer,\r\n lr_scheduler,\r\n lp_saver,\r\n log_interval,\r\n num_classes,\r\n val_metric,\r\n train_metric,\r\n use_cuda):\r\n \"\"\"\r\n Main procedure for training model.\r\n\r\n Parameters:\r\n ----------\r\n batch_size : int\r\n Training batch size.\r\n num_epochs : int\r\n Number of training epochs.\r\n start_epoch1 : int\r\n Number of starting epoch (1-based).\r\n train_data : DataLoader\r\n Data loader (training subset).\r\n val_data : DataLoader\r\n Data loader (validation subset).\r\n net : Module\r\n Model.\r\n optimizer : Optimizer\r\n Optimizer.\r\n lr_scheduler : LRScheduler\r\n Learning rate scheduler.\r\n lp_saver : TrainLogParamSaver\r\n Model/trainer state saver.\r\n log_interval : int\r\n Batch count period for logging.\r\n num_classes : int\r\n Number of model classes.\r\n val_metric : EvalMetric\r\n Metric object instance (validation subset).\r\n train_metric : EvalMetric\r\n Metric object instance (training subset).\r\n use_cuda : bool\r\n Whether to use CUDA.\r\n \"\"\"\r\n assert (num_classes > 0)\r\n\r\n L = nn.CrossEntropyLoss()\r\n if use_cuda:\r\n L = L.cuda()\r\n\r\n assert (type(start_epoch1) == int)\r\n assert (start_epoch1 >= 1)\r\n if start_epoch1 > 1:\r\n logging.info(\"Start training from [Epoch {}]\".format(start_epoch1))\r\n validate(\r\n metric=val_metric,\r\n net=net,\r\n val_data=val_data,\r\n use_cuda=use_cuda)\r\n val_accuracy_msg = report_accuracy(metric=val_metric)\r\n logging.info(\"[Epoch {}] validation: {}\".format(start_epoch1 - 1, val_accuracy_msg))\r\n\r\n gtic = time.time()\r\n for epoch in range(start_epoch1 - 1, num_epochs):\r\n lr_scheduler.step()\r\n\r\n train_loss = train_epoch(\r\n epoch=epoch,\r\n net=net,\r\n train_metric=train_metric,\r\n train_data=train_data,\r\n use_cuda=use_cuda,\r\n L=L,\r\n optimizer=optimizer,\r\n # lr_scheduler,\r\n batch_size=batch_size,\r\n log_interval=log_interval)\r\n\r\n validate(\r\n metric=val_metric,\r\n net=net,\r\n val_data=val_data,\r\n use_cuda=use_cuda)\r\n val_accuracy_msg = report_accuracy(metric=val_metric)\r\n logging.info(\"[Epoch {}] validation: {}\".format(epoch + 1, val_accuracy_msg))\r\n\r\n if lp_saver is not None:\r\n state = {\r\n \"epoch\": epoch + 1,\r\n \"state_dict\": net.state_dict(),\r\n \"optimizer\": optimizer.state_dict(),\r\n }\r\n lp_saver_kwargs = {\"state\": state}\r\n val_acc_values = val_metric.get()[1]\r\n train_acc_values = train_metric.get()[1]\r\n val_acc_values = val_acc_values if type(val_acc_values) == list else [val_acc_values]\r\n train_acc_values = train_acc_values if type(train_acc_values) == list else [train_acc_values]\r\n lp_saver.epoch_test_end_callback(\r\n epoch1=(epoch + 1),\r\n params=(val_acc_values + train_acc_values + [train_loss, optimizer.param_groups[0][\"lr\"]]),\r\n **lp_saver_kwargs)\r\n\r\n logging.info(\"Total time cost: {:.2f} sec\".format(time.time() - gtic))\r\n if lp_saver is not None:\r\n opt_metric_name = get_metric_name(val_metric, lp_saver.acc_ind)\r\n logging.info(\"Best {}: {:.4f} at {} epoch\".format(\r\n opt_metric_name, lp_saver.best_eval_metric_value, lp_saver.best_eval_metric_epoch))\r\n\r\n\r\ndef main():\r\n \"\"\"\r\n Main body of script.\r\n \"\"\"\r\n args = parse_args()\r\n args.seed = init_rand(seed=args.seed)\r\n\r\n _, log_file_exist = initialize_logging(\r\n logging_dir_path=args.save_dir,\r\n logging_file_name=args.logging_file_name,\r\n script_args=args,\r\n log_packages=args.log_packages,\r\n log_pip_packages=args.log_pip_packages)\r\n\r\n use_cuda, batch_size = prepare_pt_context(\r\n num_gpus=args.num_gpus,\r\n batch_size=args.batch_size)\r\n\r\n net = prepare_model(\r\n model_name=args.model,\r\n use_pretrained=args.use_pretrained,\r\n pretrained_model_file_path=args.resume.strip(),\r\n use_cuda=use_cuda)\r\n real_net = net.module if hasattr(net, \"module\") else net\r\n assert (hasattr(real_net, \"num_classes\"))\r\n num_classes = real_net.num_classes\r\n\r\n ds_metainfo = get_dataset_metainfo(dataset_name=args.dataset)\r\n ds_metainfo.update(args=args)\r\n\r\n train_data = get_train_data_source(\r\n ds_metainfo=ds_metainfo,\r\n batch_size=batch_size,\r\n num_workers=args.num_workers)\r\n val_data = get_val_data_source(\r\n ds_metainfo=ds_metainfo,\r\n batch_size=batch_size,\r\n num_workers=args.num_workers)\r\n\r\n optimizer, lr_scheduler, start_epoch = prepare_trainer(\r\n net=net,\r\n optimizer_name=args.optimizer_name,\r\n wd=args.wd,\r\n momentum=args.momentum,\r\n lr_mode=args.lr_mode,\r\n lr=args.lr,\r\n lr_decay_period=args.lr_decay_period,\r\n lr_decay_epoch=args.lr_decay_epoch,\r\n lr_decay=args.lr_decay,\r\n num_epochs=args.num_epochs,\r\n state_file_path=args.resume_state)\r\n\r\n if args.save_dir and args.save_interval:\r\n param_names = ds_metainfo.val_metric_capts + ds_metainfo.train_metric_capts + [\"Train.Loss\", \"LR\"]\r\n lp_saver = TrainLogParamSaver(\r\n checkpoint_file_name_prefix=\"{}_{}\".format(ds_metainfo.short_label, args.model),\r\n last_checkpoint_file_name_suffix=\"last\",\r\n best_checkpoint_file_name_suffix=None,\r\n last_checkpoint_dir_path=args.save_dir,\r\n best_checkpoint_dir_path=None,\r\n last_checkpoint_file_count=2,\r\n best_checkpoint_file_count=2,\r\n checkpoint_file_save_callback=save_params,\r\n checkpoint_file_exts=(\".pth\", \".states\"),\r\n save_interval=args.save_interval,\r\n num_epochs=args.num_epochs,\r\n param_names=param_names,\r\n acc_ind=ds_metainfo.saver_acc_ind,\r\n # bigger=[True],\r\n # mask=None,\r\n score_log_file_path=os.path.join(args.save_dir, \"score.log\"),\r\n score_log_attempt_value=args.attempt,\r\n best_map_log_file_path=os.path.join(args.save_dir, \"best_map.log\"))\r\n else:\r\n lp_saver = None\r\n\r\n train_net(\r\n batch_size=batch_size,\r\n num_epochs=args.num_epochs,\r\n start_epoch1=args.start_epoch,\r\n train_data=train_data,\r\n val_data=val_data,\r\n net=net,\r\n optimizer=optimizer,\r\n lr_scheduler=lr_scheduler,\r\n lp_saver=lp_saver,\r\n log_interval=args.log_interval,\r\n num_classes=num_classes,\r\n val_metric=get_composite_metric(ds_metainfo.val_metric_names, ds_metainfo.val_metric_extra_kwargs),\r\n train_metric=get_composite_metric(ds_metainfo.train_metric_names, ds_metainfo.train_metric_extra_kwargs),\r\n use_cuda=use_cuda)\r\n\r\n\r\nif __name__ == \"__main__\":\r\n main()\r\n",
"\"\"\"\n Script for training model on Keras.\n\"\"\"\n\nimport argparse\nimport time\nimport logging\nimport os\nimport numpy as np\nimport random\nimport keras\nfrom keras.models import load_model\nfrom keras.callbacks import ModelCheckpoint\nimport mxnet as mx\nfrom common.logger_utils import initialize_logging\nfrom keras_.utils import prepare_ke_context, prepare_model, get_data_rec, get_data_generator, backend_agnostic_compile\n\n\ndef parse_args():\n \"\"\"\n Parse python script parameters.\n\n Returns:\n -------\n ArgumentParser\n Resulted args.\n \"\"\"\n parser = argparse.ArgumentParser(\n description=\"Train a model for image classification (Keras)\",\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument(\n \"--rec-train\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/train.rec\",\n help=\"the training data\")\n parser.add_argument(\n \"--rec-train-idx\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/train.idx\",\n help='the index of training data')\n parser.add_argument(\n \"--rec-val\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/val.rec\",\n help=\"the validation data\")\n parser.add_argument(\n \"--rec-val-idx\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/val.idx\",\n help=\"the index of validation data\")\n\n parser.add_argument(\n \"--model\",\n type=str,\n required=True,\n help=\"type of model to use. see model_provider for options\")\n parser.add_argument(\n \"--use-pretrained\",\n action=\"store_true\",\n help=\"enable using pretrained model from github repo\")\n parser.add_argument(\n \"--dtype\",\n type=str,\n default=\"float32\",\n help=\"data type for training\")\n parser.add_argument(\n \"--resume\",\n type=str,\n default=\"\",\n help=\"resume from previously saved parameters if not None\")\n parser.add_argument(\n \"--resume-state\",\n type=str,\n default=\"\",\n help=\"resume from previously saved optimizer state if not None\")\n\n parser.add_argument(\n \"--input-size\",\n type=int,\n default=224,\n help=\"size of the input for model\")\n parser.add_argument(\n \"--resize-inv-factor\",\n type=float,\n default=0.875,\n help=\"inverted ratio for input image crop\")\n\n parser.add_argument(\n \"--num-gpus\",\n type=int,\n default=0,\n help=\"number of gpus to use\")\n parser.add_argument(\n \"-j\",\n \"--num-data-workers\",\n dest=\"num_workers\",\n default=4,\n type=int,\n help=\"number of preprocessing workers\")\n\n parser.add_argument(\n \"--batch-size\",\n type=int,\n default=512,\n help=\"training batch size per device (CPU/GPU)\")\n parser.add_argument(\n \"--num-epochs\",\n type=int,\n default=120,\n help=\"number of training epochs\")\n parser.add_argument(\n \"--start-epoch\",\n type=int,\n default=1,\n help=\"starting epoch for resuming, default is 1 for new training\")\n parser.add_argument(\n \"--attempt\",\n type=int,\n default=1,\n help=\"current number of training\")\n\n parser.add_argument(\n \"--optimizer-name\",\n type=str,\n default=\"nag\",\n help=\"optimizer name\")\n parser.add_argument(\n \"--lr\",\n type=float,\n default=0.1,\n help=\"learning rate\")\n parser.add_argument(\n \"--momentum\",\n type=float,\n default=0.9,\n help=\"momentum value for optimizer\")\n parser.add_argument(\n \"--wd\",\n type=float,\n default=0.0001,\n help=\"weight decay rate\")\n\n parser.add_argument(\n \"--log-interval\",\n type=int,\n default=50,\n help=\"number of batches to wait before logging\")\n parser.add_argument(\n \"--save-interval\",\n type=int,\n default=4,\n help=\"saving parameters epoch interval, best model will always be saved\")\n parser.add_argument(\n \"--save-dir\",\n type=str,\n default=\"\",\n help=\"directory of saved models and log-files\")\n parser.add_argument(\n \"--logging-file-name\",\n type=str,\n default=\"train.log\",\n help=\"filename of training log\")\n\n parser.add_argument(\n \"--seed\",\n type=int,\n default=-1,\n help=\"Random seed to be fixed\")\n parser.add_argument(\n \"--log-packages\",\n type=str,\n default=\"keras\",\n help=\"list of python packages for logging\")\n parser.add_argument(\n \"--log-pip-packages\",\n type=str,\n default=\"keras, keras-mxnet, keras-applications, keras-preprocessing\",\n help=\"list of pip packages for logging\")\n args = parser.parse_args()\n return args\n\n\ndef init_rand(seed):\n if seed <= 0:\n seed = np.random.randint(10000)\n random.seed(seed)\n np.random.seed(seed)\n mx.random.seed(seed)\n return seed\n\n\ndef prepare_trainer(net,\n optimizer_name,\n momentum,\n lr,\n num_gpus,\n state_file_path=None):\n\n optimizer_name = optimizer_name.lower()\n if (optimizer_name == \"sgd\") or (optimizer_name == \"nag\"):\n optimizer = keras.optimizers.SGD(\n lr=lr,\n momentum=momentum,\n nesterov=(optimizer_name == \"nag\"))\n else:\n raise ValueError(\"Usupported optimizer: {}\".format(optimizer_name))\n\n backend_agnostic_compile(\n model=net,\n loss=\"categorical_crossentropy\",\n optimizer=optimizer,\n metrics=[keras.metrics.categorical_accuracy, keras.metrics.top_k_categorical_accuracy],\n num_gpus=num_gpus)\n\n if (state_file_path is not None) and state_file_path and os.path.exists(state_file_path):\n net = load_model(filepath=state_file_path)\n return net\n\n\ndef train_net(net,\n train_gen,\n val_gen,\n train_num_examples,\n val_num_examples,\n num_epochs,\n checkpoint_filepath,\n start_epoch1):\n checkpointer = ModelCheckpoint(\n filepath=checkpoint_filepath,\n verbose=1,\n save_best_only=True)\n\n tic = time.time()\n\n net.fit_generator(\n generator=train_gen,\n samples_per_epoch=train_num_examples,\n epochs=num_epochs,\n verbose=True,\n callbacks=[checkpointer],\n validation_data=val_gen,\n validation_steps=val_num_examples,\n class_weight=None,\n max_queue_size=10,\n workers=1,\n use_multiprocessing=False,\n shuffle=True,\n initial_epoch=(start_epoch1 - 1))\n\n logging.info(\"Time cost: {:.4f} sec\".format(\n time.time() - tic))\n\n\ndef main():\n \"\"\"\n Main body of script.\n \"\"\"\n args = parse_args()\n args.seed = init_rand(seed=args.seed)\n\n _, log_file_exist = initialize_logging(\n logging_dir_path=args.save_dir,\n logging_file_name=args.logging_file_name,\n script_args=args,\n log_packages=args.log_packages,\n log_pip_packages=args.log_pip_packages)\n\n batch_size = prepare_ke_context(\n num_gpus=args.num_gpus,\n batch_size=args.batch_size)\n\n net = prepare_model(\n model_name=args.model,\n use_pretrained=args.use_pretrained,\n pretrained_model_file_path=args.resume.strip())\n num_classes = net.classes if hasattr(net, \"classes\") else 1000\n input_image_size = net.in_size if hasattr(net, \"in_size\") else (args.input_size, args.input_size)\n\n train_data, val_data = get_data_rec(\n rec_train=args.rec_train,\n rec_train_idx=args.rec_train_idx,\n rec_val=args.rec_val,\n rec_val_idx=args.rec_val_idx,\n batch_size=batch_size,\n num_workers=args.num_workers,\n input_image_size=input_image_size,\n resize_inv_factor=args.resize_inv_factor)\n train_gen = get_data_generator(\n data_iterator=train_data,\n num_classes=num_classes)\n val_gen = get_data_generator(\n data_iterator=val_data,\n num_classes=num_classes)\n\n net = prepare_trainer(\n net=net,\n optimizer_name=args.optimizer_name,\n momentum=args.momentum,\n lr=args.lr,\n num_gpus=args.num_gpus,\n state_file_path=args.resume_state)\n\n train_net(\n net=net,\n train_gen=train_gen,\n val_gen=val_gen,\n train_num_examples=1281167,\n val_num_examples=50048,\n num_epochs=args.num_epochs,\n checkpoint_filepath=os.path.join(args.save_dir, \"imagenet_{}.h5\".format(args.model)),\n start_epoch1=args.start_epoch)\n\n\nif __name__ == \"__main__\":\n main()\n",
"\"\"\"\n SE-ResNet for CIFAR/SVHN, implemented in Chainer.\n Original paper: 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\"\"\"\n\n__all__ = ['CIFARSEResNet', 'seresnet20_cifar10', 'seresnet20_cifar100', 'seresnet20_svhn',\n 'seresnet56_cifar10', 'seresnet56_cifar100', 'seresnet56_svhn',\n 'seresnet110_cifar10', 'seresnet110_cifar100', 'seresnet110_svhn',\n 'seresnet164bn_cifar10', 'seresnet164bn_cifar100', 'seresnet164bn_svhn',\n 'seresnet272bn_cifar10', 'seresnet272bn_cifar100', 'seresnet272bn_svhn',\n 'seresnet542bn_cifar10', 'seresnet542bn_cifar100', 'seresnet542bn_svhn',\n 'seresnet1001_cifar10', 'seresnet1001_cifar100', 'seresnet1001_svhn',\n 'seresnet1202_cifar10', 'seresnet1202_cifar100', 'seresnet1202_svhn']\n\nimport os\nimport chainer.functions as F\nimport chainer.links as L\nfrom chainer import Chain\nfrom functools import partial\nfrom chainer.serializers import load_npz\nfrom .common import conv3x3_block, SimpleSequential\nfrom .seresnet import SEResUnit\n\n\nclass CIFARSEResNet(Chain):\n \"\"\"\n SE-ResNet model for CIFAR from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n channels : list of list of int\n Number of output channels for each unit.\n init_block_channels : int\n Number of output channels for the initial unit.\n bottleneck : bool\n Whether to use a bottleneck or simple block in units.\n in_channels : int, default 3\n Number of input channels.\n in_size : tuple of two ints, default (32, 32)\n Spatial size of the expected input image.\n classes : int, default 10\n Number of classification classes.\n \"\"\"\n def __init__(self,\n channels,\n init_block_channels,\n bottleneck,\n in_channels=3,\n in_size=(32, 32),\n classes=10):\n super(CIFARSEResNet, self).__init__()\n self.in_size = in_size\n self.classes = classes\n\n with self.init_scope():\n self.features = SimpleSequential()\n with self.features.init_scope():\n setattr(self.features, \"init_block\", conv3x3_block(\n in_channels=in_channels,\n out_channels=init_block_channels))\n in_channels = init_block_channels\n for i, channels_per_stage in enumerate(channels):\n stage = SimpleSequential()\n with stage.init_scope():\n for j, out_channels in enumerate(channels_per_stage):\n stride = 2 if (j == 0) and (i != 0) else 1\n setattr(stage, \"unit{}\".format(j + 1), SEResUnit(\n in_channels=in_channels,\n out_channels=out_channels,\n stride=stride,\n bottleneck=bottleneck,\n conv1_stride=False))\n in_channels = out_channels\n setattr(self.features, \"stage{}\".format(i + 1), stage)\n setattr(self.features, \"final_pool\", partial(\n F.average_pooling_2d,\n ksize=8,\n stride=1))\n\n self.output = SimpleSequential()\n with self.output.init_scope():\n setattr(self.output, \"flatten\", partial(\n F.reshape,\n shape=(-1, in_channels)))\n setattr(self.output, \"fc\", L.Linear(\n in_size=in_channels,\n out_size=classes))\n\n def __call__(self, x):\n x = self.features(x)\n x = self.output(x)\n return x\n\n\ndef get_seresnet_cifar(classes,\n blocks,\n bottleneck,\n model_name=None,\n pretrained=False,\n root=os.path.join(\"~\", \".chainer\", \"models\"),\n **kwargs):\n \"\"\"\n Create SE-ResNet model for CIFAR with specific parameters.\n\n Parameters:\n ----------\n classes : int\n Number of classification classes.\n blocks : int\n Number of blocks.\n bottleneck : bool\n Whether to use a bottleneck or simple block in units.\n model_name : str or None, default None\n Model name for loading pretrained model.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n assert (classes in [10, 100])\n\n if bottleneck:\n assert ((blocks - 2) % 9 == 0)\n layers = [(blocks - 2) // 9] * 3\n else:\n assert ((blocks - 2) % 6 == 0)\n layers = [(blocks - 2) // 6] * 3\n\n channels_per_layers = [16, 32, 64]\n init_block_channels = 16\n\n channels = [[ci] * li for (ci, li) in zip(channels_per_layers, layers)]\n\n if bottleneck:\n channels = [[cij * 4 for cij in ci] for ci in channels]\n\n net = CIFARSEResNet(\n channels=channels,\n init_block_channels=init_block_channels,\n bottleneck=bottleneck,\n classes=classes,\n **kwargs)\n\n if pretrained:\n if (model_name is None) or (not model_name):\n raise ValueError(\"Parameter `model_name` should be properly initialized for loading pretrained model.\")\n from .model_store import get_model_file\n load_npz(\n file=get_model_file(\n model_name=model_name,\n local_model_store_dir_path=root),\n obj=net)\n\n return net\n\n\ndef seresnet20_cifar10(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-20 model for CIFAR-10 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=20, bottleneck=False, model_name=\"seresnet20_cifar10\", **kwargs)\n\n\ndef seresnet20_cifar100(classes=100, **kwargs):\n \"\"\"\n SE-ResNet-20 model for CIFAR-100 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 100\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=20, bottleneck=False, model_name=\"seresnet20_cifar100\", **kwargs)\n\n\ndef seresnet20_svhn(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-20 model for SVHN from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=20, bottleneck=False, model_name=\"seresnet20_svhn\", **kwargs)\n\n\ndef seresnet56_cifar10(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-56 model for CIFAR-10 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=56, bottleneck=False, model_name=\"seresnet56_cifar10\", **kwargs)\n\n\ndef seresnet56_cifar100(classes=100, **kwargs):\n \"\"\"\n SE-ResNet-56 model for CIFAR-100 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 100\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=56, bottleneck=False, model_name=\"seresnet56_cifar100\", **kwargs)\n\n\ndef seresnet56_svhn(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-56 model for SVHN from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=56, bottleneck=False, model_name=\"seresnet56_svhn\", **kwargs)\n\n\ndef seresnet110_cifar10(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-110 model for CIFAR-10 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=110, bottleneck=False, model_name=\"seresnet110_cifar10\", **kwargs)\n\n\ndef seresnet110_cifar100(classes=100, **kwargs):\n \"\"\"\n SE-ResNet-110 model for CIFAR-100 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 100\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=110, bottleneck=False, model_name=\"seresnet110_cifar100\",\n **kwargs)\n\n\ndef seresnet110_svhn(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-110 model for SVHN from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=110, bottleneck=False, model_name=\"seresnet110_svhn\", **kwargs)\n\n\ndef seresnet164bn_cifar10(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-164(BN) model for CIFAR-10 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=164, bottleneck=True, model_name=\"seresnet164bn_cifar10\",\n **kwargs)\n\n\ndef seresnet164bn_cifar100(classes=100, **kwargs):\n \"\"\"\n SE-ResNet-164(BN) model for CIFAR-100 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 100\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=164, bottleneck=True, model_name=\"seresnet164bn_cifar100\",\n **kwargs)\n\n\ndef seresnet164bn_svhn(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-164(BN) model for SVHN from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=164, bottleneck=True, model_name=\"seresnet164bn_svhn\", **kwargs)\n\n\ndef seresnet272bn_cifar10(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-272(BN) model for CIFAR-10 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=272, bottleneck=True, model_name=\"seresnet272bn_cifar10\",\n **kwargs)\n\n\ndef seresnet272bn_cifar100(classes=100, **kwargs):\n \"\"\"\n SE-ResNet-272(BN) model for CIFAR-100 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 100\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=272, bottleneck=True, model_name=\"seresnet272bn_cifar100\",\n **kwargs)\n\n\ndef seresnet272bn_svhn(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-272(BN) model for SVHN from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=272, bottleneck=True, model_name=\"seresnet272bn_svhn\", **kwargs)\n\n\ndef seresnet542bn_cifar10(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-542(BN) model for CIFAR-10 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=542, bottleneck=True, model_name=\"seresnet542bn_cifar10\",\n **kwargs)\n\n\ndef seresnet542bn_cifar100(classes=100, **kwargs):\n \"\"\"\n SE-ResNet-542(BN) model for CIFAR-100 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 100\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=542, bottleneck=True, model_name=\"seresnet542bn_cifar100\",\n **kwargs)\n\n\ndef seresnet542bn_svhn(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-542(BN) model for SVHN from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=542, bottleneck=True, model_name=\"seresnet542bn_svhn\", **kwargs)\n\n\ndef seresnet1001_cifar10(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-1001 model for CIFAR-10 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=1001, bottleneck=True, model_name=\"seresnet1001_cifar10\",\n **kwargs)\n\n\ndef seresnet1001_cifar100(classes=100, **kwargs):\n \"\"\"\n SE-ResNet-1001 model for CIFAR-100 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 100\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=1001, bottleneck=True, model_name=\"seresnet1001_cifar100\",\n **kwargs)\n\n\ndef seresnet1001_svhn(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-1001 model for SVHN from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=1001, bottleneck=True, model_name=\"seresnet1001_svhn\", **kwargs)\n\n\ndef seresnet1202_cifar10(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-1202 model for CIFAR-10 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=1202, bottleneck=False, model_name=\"seresnet1202_cifar10\",\n **kwargs)\n\n\ndef seresnet1202_cifar100(classes=100, **kwargs):\n \"\"\"\n SE-ResNet-1202 model for CIFAR-100 from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 100\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=1202, bottleneck=False, model_name=\"seresnet1202_cifar100\",\n **kwargs)\n\n\ndef seresnet1202_svhn(classes=10, **kwargs):\n \"\"\"\n SE-ResNet-1202 model for SVHN from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n\n Parameters:\n ----------\n classes : int, default 10\n Number of classification classes.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.chainer/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_seresnet_cifar(classes=classes, blocks=1202, bottleneck=False, model_name=\"seresnet1202_svhn\", **kwargs)\n\n\ndef _test():\n import numpy as np\n import chainer\n\n chainer.global_config.train = False\n\n pretrained = False\n\n models = [\n (seresnet20_cifar10, 10),\n (seresnet20_cifar100, 100),\n (seresnet20_svhn, 10),\n (seresnet56_cifar10, 10),\n (seresnet56_cifar100, 100),\n (seresnet56_svhn, 10),\n (seresnet110_cifar10, 10),\n (seresnet110_cifar100, 100),\n (seresnet110_svhn, 10),\n (seresnet164bn_cifar10, 10),\n (seresnet164bn_cifar100, 100),\n (seresnet164bn_svhn, 10),\n (seresnet272bn_cifar10, 10),\n (seresnet272bn_cifar100, 100),\n (seresnet272bn_svhn, 10),\n (seresnet542bn_cifar10, 10),\n (seresnet542bn_cifar100, 100),\n (seresnet542bn_svhn, 10),\n (seresnet1001_cifar10, 10),\n (seresnet1001_cifar100, 100),\n (seresnet1001_svhn, 10),\n (seresnet1202_cifar10, 10),\n (seresnet1202_cifar100, 100),\n (seresnet1202_svhn, 10),\n ]\n\n for model, classes in models:\n\n net = model(pretrained=pretrained)\n weight_count = net.count_params()\n print(\"m={}, {}\".format(model.__name__, weight_count))\n assert (model != seresnet20_cifar10 or weight_count == 274847)\n assert (model != seresnet20_cifar100 or weight_count == 280697)\n assert (model != seresnet20_svhn or weight_count == 274847)\n assert (model != seresnet56_cifar10 or weight_count == 862889)\n assert (model != seresnet56_cifar100 or weight_count == 868739)\n assert (model != seresnet56_svhn or weight_count == 862889)\n assert (model != seresnet110_cifar10 or weight_count == 1744952)\n assert (model != seresnet110_cifar100 or weight_count == 1750802)\n assert (model != seresnet110_svhn or weight_count == 1744952)\n assert (model != seresnet164bn_cifar10 or weight_count == 1906258)\n assert (model != seresnet164bn_cifar100 or weight_count == 1929388)\n assert (model != seresnet164bn_svhn or weight_count == 1906258)\n assert (model != seresnet272bn_cifar10 or weight_count == 3153826)\n assert (model != seresnet272bn_cifar100 or weight_count == 3176956)\n assert (model != seresnet272bn_svhn or weight_count == 3153826)\n assert (model != seresnet542bn_cifar10 or weight_count == 6272746)\n assert (model != seresnet542bn_cifar100 or weight_count == 6295876)\n assert (model != seresnet542bn_svhn or weight_count == 6272746)\n assert (model != seresnet1001_cifar10 or weight_count == 11574910)\n assert (model != seresnet1001_cifar100 or weight_count == 11598040)\n assert (model != seresnet1001_svhn or weight_count == 11574910)\n assert (model != seresnet1202_cifar10 or weight_count == 19582226)\n assert (model != seresnet1202_cifar100 or weight_count == 19588076)\n assert (model != seresnet1202_svhn or weight_count == 19582226)\n\n x = np.zeros((1, 3, 32, 32), np.float32)\n y = net(x)\n assert (y.shape == (1, classes))\n\n\nif __name__ == \"__main__\":\n _test()\n",
"\"\"\"\n InceptionResNetV1 for ImageNet-1K, implemented in TensorFlow.\n Original paper: 'Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning,'\n https://arxiv.org/abs/1602.07261.\n\"\"\"\n\n__all__ = ['InceptionResNetV1', 'inceptionresnetv1', 'InceptionAUnit', 'InceptionBUnit', 'InceptionCUnit',\n 'ReductionAUnit', 'ReductionBUnit']\n\nimport os\nimport tensorflow as tf\nimport tensorflow.keras.layers as nn\nfrom .common import MaxPool2d, BatchNorm, conv1x1, conv1x1_block, conv3x3_block, Concurrent, flatten,\\\n is_channels_first, SimpleSequential\nfrom .inceptionv3 import MaxPoolBranch, Conv1x1Branch, ConvSeqBranch\n\n\nclass InceptionAUnit(nn.Layer):\n \"\"\"\n InceptionResNetV1 type Inception-A unit.\n\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels_list : list of int\n List for numbers of output channels.\n bn_eps : float\n Small float added to variance in Batch norm.\n data_format : str, default 'channels_last'\n The ordering of the dimensions in tensors.\n \"\"\"\n def __init__(self,\n in_channels,\n out_channels_list,\n bn_eps,\n data_format=\"channels_last\",\n **kwargs):\n super(InceptionAUnit, self).__init__(**kwargs)\n self.scale = 0.17\n\n self.branches = Concurrent(\n data_format=data_format,\n name=\"branches\")\n self.branches.children.append(Conv1x1Branch(\n in_channels=in_channels,\n out_channels=out_channels_list[0],\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch1\"))\n self.branches.children.append(ConvSeqBranch(\n in_channels=in_channels,\n out_channels_list=out_channels_list[1:3],\n kernel_size_list=(1, 3),\n strides_list=(1, 1),\n padding_list=(0, 1),\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch2\"))\n self.branches.children.append(ConvSeqBranch(\n in_channels=in_channels,\n out_channels_list=out_channels_list[3:6],\n kernel_size_list=(1, 3, 3),\n strides_list=(1, 1, 1),\n padding_list=(0, 1, 1),\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch3\"))\n conv_in_channels = out_channels_list[0] + out_channels_list[2] + out_channels_list[5]\n self.conv = conv1x1(\n in_channels=conv_in_channels,\n out_channels=in_channels,\n use_bias=True,\n data_format=data_format,\n name=\"conv\")\n self.activ = nn.ReLU()\n\n def call(self, x, training=None):\n identity = x\n x = self.branches(x, training=training)\n x = self.conv(x, training=training)\n x = self.scale * x + identity\n x = self.activ(x)\n return x\n\n\nclass InceptionBUnit(nn.Layer):\n \"\"\"\n InceptionResNetV1 type Inception-B unit.\n\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels_list : list of int\n List for numbers of output channels.\n bn_eps : float\n Small float added to variance in Batch norm.\n data_format : str, default 'channels_last'\n The ordering of the dimensions in tensors.\n \"\"\"\n def __init__(self,\n in_channels,\n out_channels_list,\n bn_eps,\n data_format=\"channels_last\",\n **kwargs):\n super(InceptionBUnit, self).__init__(**kwargs)\n self.scale = 0.10\n\n self.branches = Concurrent(\n data_format=data_format,\n name=\"branches\")\n self.branches.children.append(Conv1x1Branch(\n in_channels=in_channels,\n out_channels=out_channels_list[0],\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch1\"))\n self.branches.children.append(ConvSeqBranch(\n in_channels=in_channels,\n out_channels_list=out_channels_list[1:4],\n kernel_size_list=(1, (1, 7), (7, 1)),\n strides_list=(1, 1, 1),\n padding_list=(0, (0, 3), (3, 0)),\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch2\"))\n conv_in_channels = out_channels_list[0] + out_channels_list[3]\n self.conv = conv1x1(\n in_channels=conv_in_channels,\n out_channels=in_channels,\n use_bias=True,\n data_format=data_format,\n name=\"conv\")\n self.activ = nn.ReLU()\n\n def call(self, x, training=None):\n identity = x\n x = self.branches(x, training=training)\n x = self.conv(x, training=training)\n x = self.scale * x + identity\n x = self.activ(x)\n return x\n\n\nclass InceptionCUnit(nn.Layer):\n \"\"\"\n InceptionResNetV1 type Inception-C unit.\n\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels_list : list of int\n List for numbers of output channels.\n bn_eps : float\n Small float added to variance in Batch norm.\n scale : float, default 1.0\n Scale value for residual branch.\n activate : bool, default True\n Whether activate the convolution block.\n data_format : str, default 'channels_last'\n The ordering of the dimensions in tensors.\n \"\"\"\n def __init__(self,\n in_channels,\n out_channels_list,\n bn_eps,\n scale=0.2,\n activate=True,\n data_format=\"channels_last\",\n **kwargs):\n super(InceptionCUnit, self).__init__(**kwargs)\n self.activate = activate\n self.scale = scale\n\n self.branches = Concurrent(\n data_format=data_format,\n name=\"branches\")\n self.branches.children.append(Conv1x1Branch(\n in_channels=in_channels,\n out_channels=out_channels_list[0],\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch1\"))\n self.branches.children.append(ConvSeqBranch(\n in_channels=in_channels,\n out_channels_list=out_channels_list[1:4],\n kernel_size_list=(1, (1, 3), (3, 1)),\n strides_list=(1, 1, 1),\n padding_list=(0, (0, 1), (1, 0)),\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch2\"))\n conv_in_channels = out_channels_list[0] + out_channels_list[3]\n self.conv = conv1x1(\n in_channels=conv_in_channels,\n out_channels=in_channels,\n use_bias=True,\n data_format=data_format,\n name=\"conv\")\n if self.activate:\n self.activ = nn.ReLU()\n\n def call(self, x, training=None):\n identity = x\n x = self.branches(x, training=training)\n x = self.conv(x, training=training)\n x = self.scale * x + identity\n if self.activate:\n x = self.activ(x)\n return x\n\n\nclass ReductionAUnit(nn.Layer):\n \"\"\"\n InceptionResNetV1 type Reduction-A unit.\n\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels_list : list of int\n List for numbers of output channels.\n bn_eps : float\n Small float added to variance in Batch norm.\n data_format : str, default 'channels_last'\n The ordering of the dimensions in tensors.\n \"\"\"\n def __init__(self,\n in_channels,\n out_channels_list,\n bn_eps,\n data_format=\"channels_last\",\n **kwargs):\n super(ReductionAUnit, self).__init__(**kwargs)\n self.branches = Concurrent(\n data_format=data_format,\n name=\"branches\")\n self.branches.children.append(ConvSeqBranch(\n in_channels=in_channels,\n out_channels_list=out_channels_list[0:1],\n kernel_size_list=(3,),\n strides_list=(2,),\n padding_list=(0,),\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch1\"))\n self.branches.children.append(ConvSeqBranch(\n in_channels=in_channels,\n out_channels_list=out_channels_list[1:4],\n kernel_size_list=(1, 3, 3),\n strides_list=(1, 1, 2),\n padding_list=(0, 1, 0),\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch2\"))\n self.branches.children.append(MaxPoolBranch(\n data_format=data_format,\n name=\"branch3\"))\n\n def call(self, x, training=None):\n x = self.branches(x, training=training)\n return x\n\n\nclass ReductionBUnit(nn.Layer):\n \"\"\"\n InceptionResNetV1 type Reduction-B unit.\n\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels_list : list of int\n List for numbers of output channels.\n bn_eps : float\n Small float added to variance in Batch norm.\n data_format : str, default 'channels_last'\n The ordering of the dimensions in tensors.\n \"\"\"\n def __init__(self,\n in_channels,\n out_channels_list,\n bn_eps,\n data_format=\"channels_last\",\n **kwargs):\n super(ReductionBUnit, self).__init__(**kwargs)\n self.branches = Concurrent(\n data_format=data_format,\n name=\"branches\")\n self.branches.children.append(ConvSeqBranch(\n in_channels=in_channels,\n out_channels_list=out_channels_list[0:2],\n kernel_size_list=(1, 3),\n strides_list=(1, 2),\n padding_list=(0, 0),\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch1\"))\n self.branches.children.append(ConvSeqBranch(\n in_channels=in_channels,\n out_channels_list=out_channels_list[2:4],\n kernel_size_list=(1, 3),\n strides_list=(1, 2),\n padding_list=(0, 0),\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch2\"))\n self.branches.children.append(ConvSeqBranch(\n in_channels=in_channels,\n out_channels_list=out_channels_list[4:7],\n kernel_size_list=(1, 3, 3),\n strides_list=(1, 1, 2),\n padding_list=(0, 1, 0),\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"branch3\"))\n self.branches.children.append(MaxPoolBranch(\n data_format=data_format,\n name=\"branch4\"))\n\n def call(self, x, training=None):\n x = self.branches(x, training=training)\n return x\n\n\nclass InceptInitBlock(nn.Layer):\n \"\"\"\n InceptionResNetV1 specific initial block.\n\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n bn_eps : float\n Small float added to variance in Batch norm.\n data_format : str, default 'channels_last'\n The ordering of the dimensions in tensors.\n \"\"\"\n def __init__(self,\n bn_eps,\n in_channels,\n data_format=\"channels_last\",\n **kwargs):\n super(InceptInitBlock, self).__init__(**kwargs)\n self.conv1 = conv3x3_block(\n in_channels=in_channels,\n out_channels=32,\n strides=2,\n padding=0,\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"conv1\")\n self.conv2 = conv3x3_block(\n in_channels=32,\n out_channels=32,\n strides=1,\n padding=0,\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"conv2\")\n self.conv3 = conv3x3_block(\n in_channels=32,\n out_channels=64,\n strides=1,\n padding=1,\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"conv3\")\n self.pool = MaxPool2d(\n pool_size=3,\n strides=2,\n padding=0,\n data_format=data_format,\n name=\"pool\")\n self.conv4 = conv1x1_block(\n in_channels=64,\n out_channels=80,\n strides=1,\n padding=0,\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"conv4\")\n self.conv5 = conv3x3_block(\n in_channels=80,\n out_channels=192,\n strides=1,\n padding=0,\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"conv5\")\n self.conv6 = conv3x3_block(\n in_channels=192,\n out_channels=256,\n strides=2,\n padding=0,\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"conv6\")\n\n def call(self, x, training=None):\n x = self.conv1(x, training=training)\n x = self.conv2(x, training=training)\n x = self.conv3(x, training=training)\n x = self.pool(x)\n x = self.conv4(x, training=training)\n x = self.conv5(x, training=training)\n x = self.conv6(x, training=training)\n return x\n\n\nclass InceptHead(nn.Layer):\n \"\"\"\n InceptionResNetV1 specific classification block.\n\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n bn_eps : float\n Small float added to variance in Batch norm.\n dropout_rate : float\n Fraction of the input units to drop. Must be a number between 0 and 1.\n classes : int\n Number of classification classes.\n \"\"\"\n def __init__(self,\n in_channels,\n bn_eps,\n dropout_rate,\n classes,\n data_format=\"channels_last\",\n **kwargs):\n super(InceptHead, self).__init__(**kwargs)\n self.data_format = data_format\n self.use_dropout = (dropout_rate != 0.0)\n\n if dropout_rate > 0.0:\n self.dropout = nn.Dropout(\n rate=dropout_rate,\n name=\"dropout\")\n self.fc1 = nn.Dense(\n units=512,\n input_dim=in_channels,\n use_bias=False,\n name=\"fc1\")\n self.bn = BatchNorm(\n epsilon=bn_eps,\n data_format=data_format,\n name=\"bn\")\n self.fc2 = nn.Dense(\n units=classes,\n input_dim=512,\n name=\"fc2\")\n\n def call(self, x, training=None):\n x = flatten(x, self.data_format)\n if self.use_dropout:\n x = self.dropout(x, training=training)\n x = self.fc1(x)\n x = self.bn(x, training=training)\n x = self.fc2(x)\n return x\n\n\nclass InceptionResNetV1(tf.keras.Model):\n \"\"\"\n InceptionResNetV1 model from 'Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning,'\n https://arxiv.org/abs/1602.07261.\n\n Parameters:\n ----------\n dropout_rate : float, default 0.0\n Fraction of the input units to drop. Must be a number between 0 and 1.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n in_channels : int, default 3\n Number of input channels.\n in_size : tuple of two ints, default (299, 299)\n Spatial size of the expected input image.\n classes : int, default 1000\n Number of classification classes.\n data_format : str, default 'channels_last'\n The ordering of the dimensions in tensors.\n \"\"\"\n def __init__(self,\n dropout_rate=0.0,\n bn_eps=1e-5,\n in_channels=3,\n in_size=(299, 299),\n classes=1000,\n data_format=\"channels_last\",\n **kwargs):\n super(InceptionResNetV1, self).__init__(**kwargs)\n self.in_size = in_size\n self.classes = classes\n self.data_format = data_format\n layers = [5, 11, 7]\n in_channels_list = [256, 896, 1792]\n normal_out_channels_list = [[32, 32, 32, 32, 32, 32], [128, 128, 128, 128], [192, 192, 192, 192]]\n reduction_out_channels_list = [[384, 192, 192, 256], [256, 384, 256, 256, 256, 256, 256]]\n\n normal_units = [InceptionAUnit, InceptionBUnit, InceptionCUnit]\n reduction_units = [ReductionAUnit, ReductionBUnit]\n\n self.features = SimpleSequential(name=\"features\")\n self.features.add(InceptInitBlock(\n in_channels=in_channels,\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"init_block\"))\n in_channels = in_channels_list[0]\n for i, layers_per_stage in enumerate(layers):\n stage = SimpleSequential(name=\"stage{}\".format(i + 1))\n for j in range(layers_per_stage):\n if (j == 0) and (i != 0):\n unit = reduction_units[i - 1]\n out_channels_list_per_stage = reduction_out_channels_list[i - 1]\n else:\n unit = normal_units[i]\n out_channels_list_per_stage = normal_out_channels_list[i]\n if (i == len(layers) - 1) and (j == layers_per_stage - 1):\n unit_kwargs = {\"scale\": 1.0, \"activate\": False}\n else:\n unit_kwargs = {}\n stage.add(unit(\n in_channels=in_channels,\n out_channels_list=out_channels_list_per_stage,\n bn_eps=bn_eps,\n data_format=data_format,\n name=\"unit{}\".format(j + 1),\n **unit_kwargs))\n if (j == 0) and (i != 0):\n in_channels = in_channels_list[i]\n self.features.add(stage)\n self.features.add(nn.AveragePooling2D(\n pool_size=8,\n strides=1,\n data_format=data_format,\n name=\"final_pool\"))\n\n self.output1 = InceptHead(\n in_channels=in_channels,\n bn_eps=bn_eps,\n dropout_rate=dropout_rate,\n classes=classes,\n name=\"output1\")\n\n def call(self, x, training=None):\n x = self.features(x, training=training)\n x = self.output1(x, training=training)\n return x\n\n\ndef get_inceptionresnetv1(model_name=None,\n pretrained=False,\n root=os.path.join(\"~\", \".tensorflow\", \"models\"),\n **kwargs):\n \"\"\"\n Create InceptionResNetV1 model with specific parameters.\n\n Parameters:\n ----------\n model_name : str or None, default None\n Model name for loading pretrained model.\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.tensorflow/models'\n Location for keeping the model parameters.\n \"\"\"\n net = InceptionResNetV1(**kwargs)\n\n if pretrained:\n if (model_name is None) or (not model_name):\n raise ValueError(\"Parameter `model_name` should be properly initialized for loading pretrained model.\")\n from .model_store import get_model_file\n in_channels = kwargs[\"in_channels\"] if (\"in_channels\" in kwargs) else 3\n input_shape = (1,) + (in_channels,) + net.in_size if net.data_format == \"channels_first\" else\\\n (1,) + net.in_size + (in_channels,)\n net.build(input_shape=input_shape)\n net.load_weights(\n filepath=get_model_file(\n model_name=model_name,\n local_model_store_dir_path=root))\n\n return net\n\n\ndef inceptionresnetv1(**kwargs):\n \"\"\"\n InceptionResNetV1 model from 'Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning,'\n https://arxiv.org/abs/1602.07261.\n\n Parameters:\n ----------\n pretrained : bool, default False\n Whether to load the pretrained weights for model.\n root : str, default '~/.tensorflow/models'\n Location for keeping the model parameters.\n \"\"\"\n return get_inceptionresnetv1(model_name=\"inceptionresnetv1\", bn_eps=1e-3, **kwargs)\n\n\ndef _test():\n import numpy as np\n import tensorflow.keras.backend as K\n\n data_format = \"channels_last\"\n pretrained = False\n\n models = [\n inceptionresnetv1,\n ]\n\n for model in models:\n\n net = model(pretrained=pretrained, data_format=data_format)\n\n batch = 14\n x = tf.random.normal((batch, 3, 299, 299) if is_channels_first(data_format) else (batch, 299, 299, 3))\n y = net(x)\n assert (tuple(y.shape.as_list()) == (batch, 1000))\n\n weight_count = sum([np.prod(K.get_value(w).shape) for w in net.trainable_weights])\n print(\"m={}, {}\".format(model.__name__, weight_count))\n assert (model != inceptionresnetv1 or weight_count == 23995624)\n\n\nif __name__ == \"__main__\":\n _test()\n"
] | [
[
"numpy.prod"
],
[
"numpy.random.randint",
"numpy.random.seed",
"torch.nn.CrossEntropyLoss"
],
[
"numpy.random.randint",
"numpy.random.seed"
],
[
"numpy.zeros"
],
[
"tensorflow.keras.layers.Dropout",
"tensorflow.keras.layers.ReLU",
"tensorflow.keras.backend.get_value",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.layers.AveragePooling2D"
]
] |
haowei01/translate | [
"e413a981667f1038ea9ab01bd9c6d0c013b03b0c"
] | [
"pytorch_translate/rnn.py"
] | [
"#!/usr/bin/env python3\n\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.onnx.operators\nfrom fairseq import utils\nfrom fairseq.models import (\n FairseqEncoder,\n FairseqModel,\n register_model,\n register_model_architecture,\n)\nfrom pytorch_translate import rnn_cell # noqa\nfrom pytorch_translate import (\n attention,\n data as pytorch_translate_data,\n dictionary as pytorch_translate_dictionary,\n utils as pytorch_translate_utils,\n vocab_reduction,\n word_dropout,\n)\nfrom pytorch_translate.common_layers import (\n DecoderWithOutputProjection,\n Embedding,\n Linear,\n RNNLayer,\n VariableTracker,\n)\nfrom pytorch_translate.multi_model import MultiDecoder, MultiEncoder\nfrom pytorch_translate.multilingual import MultilingualDecoder, MultilingualEncoder\nfrom pytorch_translate.ngram import NGramDecoder\nfrom pytorch_translate.utils import maybe_cat, maybe_cuda\nfrom torch.nn.utils.rnn import PackedSequence, pack_padded_sequence, pad_packed_sequence\n\n\ndef torch_find(index, query, vocab_size):\n \"\"\"\n Finds elements of query from index, outputting the last (max) index for each\n query.\n preconditions: (1) index and query are flat arrays (can be different sizes)\n (2) all tokens in index and query have values < vocab_size\n \"\"\"\n full_to_index = maybe_cuda(torch.zeros(vocab_size).long())\n index_shape_range = maybe_cuda(torch.arange(index.shape[0]).long())\n full_to_index[index] = index_shape_range\n result = full_to_index[query]\n return result\n\n\ndef reorder_encoder_output(encoder_out, new_order):\n \"\"\"Reorder all outputs according to new_order.\"\"\"\n (\n unpacked_output,\n final_hiddens,\n final_cells,\n src_lengths,\n src_tokens,\n src_embeddings,\n ) = encoder_out\n unpacked_output = unpacked_output.index_select(1, new_order)\n final_hiddens = final_hiddens.index_select(1, new_order)\n final_cells = final_cells.index_select(1, new_order)\n src_lengths = src_lengths.index_select(0, new_order)\n src_tokens = src_tokens.index_select(0, new_order)\n src_embeddings = src_embeddings.index_select(1, new_order)\n return (\n unpacked_output,\n final_hiddens,\n final_cells,\n src_lengths,\n src_tokens,\n src_embeddings,\n )\n\n\n@register_model(\"rnn\")\nclass RNNModel(FairseqModel):\n def __init__(self, task, encoder, decoder):\n super().__init__(encoder, decoder)\n self.task = task\n\n @staticmethod\n def add_args(parser):\n parser.add_argument(\n \"--dropout\",\n default=0.1,\n type=float,\n metavar=\"D\",\n help=\"dropout probability\",\n )\n parser.add_argument(\n \"--encoder-embed-dim\",\n default=0,\n type=int,\n metavar=\"N\",\n help=\"encoder embedding dimension\",\n )\n parser.add_argument(\n \"--encoder-pretrained-embed\",\n default=None,\n metavar=\"FILE\",\n help=\"path to pre-trained encoder embedding\",\n )\n parser.add_argument(\n \"--encoder-freeze-embed\",\n default=False,\n action=\"store_true\",\n help=(\n \"whether to freeze the encoder embedding or allow it to be \"\n \"updated during training\"\n ),\n )\n parser.add_argument(\n \"--encoder-hidden-dim\", type=int, metavar=\"N\", help=\"encoder cell num units\"\n )\n parser.add_argument(\n \"--encoder-layers\", type=int, metavar=\"N\", help=\"number of encoder layers\"\n )\n parser.add_argument(\n \"--encoder-bidirectional\",\n action=\"store_true\",\n help=\"whether the first layer is bidirectional or not\",\n )\n parser.add_argument(\n \"--averaging-encoder\",\n default=False,\n action=\"store_true\",\n help=(\n \"whether use mean encoder hidden states as decoder initial \"\n \"states or not\"\n ),\n )\n parser.add_argument(\n \"--decoder-embed-dim\",\n default=0,\n type=int,\n metavar=\"N\",\n help=\"decoder embedding dimension\",\n )\n parser.add_argument(\n \"--decoder-pretrained-embed\",\n default=None,\n metavar=\"FILE\",\n help=\"path to pre-trained decoder embedding\",\n )\n parser.add_argument(\n \"--decoder-freeze-embed\",\n default=False,\n action=\"store_true\",\n help=(\n \"whether to freeze the decoder embedding or allow it to be \"\n \"updated during training\"\n ),\n )\n parser.add_argument(\n \"--decoder-hidden-dim\", type=int, metavar=\"N\", help=\"decoder cell num units\"\n )\n parser.add_argument(\n \"--decoder-layers\", type=int, metavar=\"N\", help=\"number of decoder layers\"\n )\n parser.add_argument(\n \"--decoder-out-embed-dim\",\n type=int,\n metavar=\"N\",\n help=\"decoder output embedding dimension\",\n )\n parser.add_argument(\n \"--decoder-out-pretrained-embed\",\n default=None,\n metavar=\"FILE\",\n help=\"path to pre-trained decoder output embedding\",\n )\n parser.add_argument(\n \"--decoder-tie-embeddings\",\n default=False,\n action=\"store_true\",\n help=\"tie the decoder word embeddings with the output projection \"\n \"weights (requires that the embedding dims be of the same size)\",\n )\n parser.add_argument(\n \"--attention-type\",\n type=str,\n metavar=\"EXPR\",\n help=\"decoder attention, defaults to dot\",\n )\n parser.add_argument(\n \"--residual-level\",\n default=None,\n type=int,\n help=(\n \"First layer where to apply a residual connection. \"\n \"The value should be greater than 0 and smaller than the number of \"\n \"layers.\"\n ),\n )\n parser.add_argument(\n \"--cell-type\",\n default=\"lstm\",\n type=str,\n metavar=\"EXPR\",\n help=\"cell type, defaults to lstm, values:lstm, milstm, layer_norm_lstm\",\n )\n\n # Granular dropout settings (if not specified these default to --dropout)\n parser.add_argument(\n \"--encoder-dropout-in\",\n type=float,\n metavar=\"D\",\n help=\"dropout probability for encoder input embedding\",\n )\n parser.add_argument(\n \"--encoder-dropout-out\",\n type=float,\n metavar=\"D\",\n help=\"dropout probability for encoder output\",\n )\n parser.add_argument(\n \"--decoder-dropout-in\",\n type=float,\n metavar=\"D\",\n help=\"dropout probability for decoder input embedding\",\n )\n parser.add_argument(\n \"--decoder-dropout-out\",\n type=float,\n metavar=\"D\",\n help=\"dropout probability for decoder output\",\n )\n parser.add_argument(\n \"--sequence-lstm\",\n action=\"store_true\",\n help=\"use nn.LSTM implementation for encoder\",\n )\n parser.add_argument(\n \"--ngram-decoder\",\n default=None,\n type=int,\n nargs=\"+\",\n help=(\n \"A single integer, or a list of integers. If \"\n \"positive, the decoder is not recurrent but a feedforward \"\n \"network with target-side n-gram history as input. The decoder \"\n \"is still conditioned on the source side via attention. If \"\n \"this parameter is a list of integers, the n-th entry applies \"\n \"to the n-th decoder (for multilingual models and \"\n \"multi-decoders)\"\n ),\n )\n parser.add_argument(\n \"--ngram-activation-type\",\n default=\"relu\",\n type=str,\n metavar=\"EXPR\",\n help=(\n \"Activation in FF layers of the ngram decoder, defaults to \"\n \"relu, values: relu, tanh\"\n ),\n )\n parser.add_argument(\n \"--multi-encoder\",\n default=None,\n type=int,\n help=(\n \"If this is positive, train n encoder networks rather than \"\n \"only one. The outputs of the encoders are concatenated before \"\n \"passing them through to the decoder.\"\n ),\n )\n parser.add_argument(\n \"--multi-decoder\",\n default=None,\n type=int,\n help=(\n \"If this is positive, train n decoder networks rather than \"\n \"only one. The predictions are combined via the method in \"\n \"--multi-decoder-combination-strategy.\"\n ),\n )\n parser.add_argument(\n \"--multi-decoder-combination-strategy\",\n default=\"bottleneck\",\n type=str,\n metavar=\"EXPR\",\n help=(\n \"Only used if --multi-decoder is positive. Controls how the \"\n \"decoders are combined with each other.\\n\"\n \"- uniform: Separate projection layers, average predictions\\n\"\n \"- uniform-probspace: Separate projection layers, average \"\n \"in probability space.\\n\"\n \"- uniform-logprobspace: Separate projection layers, average \"\n \"in log-probability space.\\n\"\n \"- unprojected: Shared projection layer, unprojected \"\n \"decoder outputs are averaged.\\n\"\n \"- deepfusion: cf. https://arxiv.org/pdf/1503.03535.pdf \\n\"\n \"- coldfusion: cf. https://arxiv.org/pdf/1708.06426.pdf \\n\"\n \"- weighted: Separate projection layers, weighted average \"\n \"of logits. Weights are learned from unprojected decoder \"\n \"outputs.\\n\"\n \"- weighted-probspace: Like 'weighted', but average in \"\n \"probability space.\\n\"\n \"- weighted-logprobspace: Like 'weighted', but average in \"\n \"log-probability space.\\n\"\n \"- weighted-unprojected: Shared projection layer, weighted \"\n \"average of decoder outputs. Weights are learned from \"\n \"unprojected decoder outputs.\\n\"\n \"- concat: Shared projection layer, decoder outputs are \"\n \"concatenated.\\n\"\n \"- bottleneck: Like 'concat' but with an additional \"\n \"bottleneck layer to reduce the size of the output embedding \"\n \"matrix.\\n\"\n \"- deep_bottleneck: Like 'bottleneck' but with an additional \"\n \"non-linear layer.\\n\"\n \"- multiplicative-unprojected: Shared projection layer, element\"\n \"-wise product of decoder outputs after ReLU.\\n\"\n \"- max-unprojected: Shared projection layer, element\"\n \"-wise max of decoder outputs.\\n\"\n ),\n )\n parser.add_argument(\n \"--multi-model-fixed-weights\",\n default=None,\n type=float,\n nargs=\"+\",\n help=(\n \"Used for weighted* combination strategies. If specified, use \"\n \"these fixed model weights rather than a gating network.\"\n ),\n )\n parser.add_argument(\n \"--multi-model-training-schedule\",\n default=\"complete\",\n type=str,\n metavar=\"EXPR\",\n help=(\n \"Only used if --multi-decoder is positive.\\n\"\n \"- 'complete': Jointly train entire network on all batches.\\n\"\n \"- 'unfreeze_single': Freeze all submodels except one for each \"\n \"training batch.\\n\"\n \"- 'unfreeze_single_encoder': Freeze all encoders except one \"\n \"for each training batch.\\n\"\n \"- 'unfreeze_single_decoder': Freeze all decoders except one \"\n \"for each training batch.\\n\"\n \"- 'unfreeze_enc_N': Freeze N-th encoder.\\n\"\n \"- 'unfreeze_dec_N': Freeze N-th decoder.\\n\"\n \"- 'unfreeze_encdec_N': Freeze N-th encoder and N-th decoder.\\n\"\n \"- 'freeze_all': Freeze all submodels, only train combination \"\n \"strategy.\\n\"\n \"- 'freeze_all_encoders': Freeze all encoders.\\n\"\n \"- 'freeze_all_decoders': Freeze all decoders.\\n\"\n \"- 'separate': Each training batch is used for only one of the \"\n \"following: Train the n-th submodel, or train combination \"\n \"strategy.\"\n ),\n )\n parser.add_argument(\n \"--multi-decoder-is-lm\",\n default=None,\n type=int,\n nargs=\"+\",\n help=(\n \"If specified, sets --attention-type=no and --encoder-hidden-dim=0\"\n \"for the n-th decoder in an adaptive ensemble.\"\n ),\n )\n parser.add_argument(\n \"--att-weighted-source-embeds\",\n default=False,\n action=\"store_true\",\n help=(\n \"whether use attention weighted src embeddings to improve rare \"\n \"words translation or not\"\n ),\n )\n parser.add_argument(\n \"--att-weighted-activation-type\",\n default=\"tanh\",\n type=str,\n metavar=\"EXPR\",\n help=(\n \"Activation in FF layers of the attention weighted src embeddings, \"\n \"defaults to relu, values: relu, tanh\"\n ),\n )\n\n # Args for vocab reduction\n vocab_reduction.add_args(parser)\n # Args for word dropout\n word_dropout.add_args(parser)\n\n @staticmethod\n def build_single_encoder(args, src_dict):\n if not args.encoder_hidden_dim:\n return DummyEncoder(src_dict, num_layers=args.encoder_layers)\n if args.sequence_lstm:\n encoder_class = LSTMSequenceEncoder\n else:\n encoder_class = RNNEncoder\n return encoder_class(\n src_dict,\n embed_dim=args.encoder_embed_dim,\n freeze_embed=args.encoder_freeze_embed,\n cell_type=args.cell_type,\n num_layers=args.encoder_layers,\n hidden_dim=args.encoder_hidden_dim,\n dropout_in=args.encoder_dropout_in,\n dropout_out=args.encoder_dropout_out,\n residual_level=args.residual_level,\n bidirectional=bool(args.encoder_bidirectional),\n word_dropout_params=args.word_dropout_params,\n pretrained_embed=args.encoder_pretrained_embed,\n left_pad=args.left_pad_source,\n )\n\n @staticmethod\n def build_single_decoder(\n args, src_dict, dst_dict, ngram_decoder=None, project_output=True, is_lm=False\n ):\n attention_type = args.attention_type\n encoder_hidden_dim = args.encoder_hidden_dim\n if is_lm:\n attention_type = \"no\"\n encoder_hidden_dim = 0\n if ngram_decoder:\n if args.ngram_activation_type == \"relu\":\n activation_fn = nn.ReLU\n elif args.ngram_activation_type == \"tanh\":\n activation_fn = nn.Tanh\n else:\n raise Exception(\n \"ngram_activation_type '%s' not implemented\"\n % args.ngram_activation_type\n )\n decoder = NGramDecoder(\n src_dict=src_dict,\n dst_dict=dst_dict,\n n=ngram_decoder,\n encoder_hidden_dim=encoder_hidden_dim,\n embed_dim=args.decoder_embed_dim,\n freeze_embed=args.decoder_freeze_embed,\n out_embed_dim=args.decoder_out_embed_dim,\n num_layers=args.decoder_layers,\n hidden_dim=args.decoder_hidden_dim,\n attention_type=attention_type,\n dropout_in=args.decoder_dropout_in,\n dropout_out=args.decoder_dropout_out,\n residual_level=args.residual_level,\n activation_fn=activation_fn,\n project_output=project_output,\n pretrained_embed=args.decoder_pretrained_embed,\n projection_pretrained_embed=args.decoder_out_pretrained_embed,\n )\n else:\n decoder = RNNDecoder(\n src_dict=src_dict,\n dst_dict=dst_dict,\n vocab_reduction_params=args.vocab_reduction_params,\n encoder_hidden_dim=encoder_hidden_dim,\n embed_dim=args.decoder_embed_dim,\n freeze_embed=args.decoder_freeze_embed,\n out_embed_dim=args.decoder_out_embed_dim,\n cell_type=args.cell_type,\n num_layers=args.decoder_layers,\n hidden_dim=args.decoder_hidden_dim,\n attention_type=attention_type,\n dropout_in=args.decoder_dropout_in,\n dropout_out=args.decoder_dropout_out,\n residual_level=args.residual_level,\n averaging_encoder=args.averaging_encoder,\n project_output=project_output,\n pretrained_embed=args.decoder_pretrained_embed,\n projection_pretrained_embed=args.decoder_out_pretrained_embed,\n tie_embeddings=args.decoder_tie_embeddings,\n att_weighted_src_embeds=args.att_weighted_src_embeds,\n src_embed_dim=args.encoder_embed_dim,\n att_weighted_activation_type=args.att_weighted_activation_type,\n )\n return decoder\n\n @classmethod\n def build_encoder(cls, args, src_dict):\n \"\"\"Build a new (multi-)encoder instance.\"\"\"\n if args.multi_encoder is not None:\n encoders = [\n RNNModel.build_single_encoder(args, src_dict)\n for _ in range(args.multi_encoder)\n ]\n encoder = MultiEncoder(\n src_dict, encoders, training_schedule=args.multi_model_training_schedule\n )\n else:\n encoder = RNNModel.build_single_encoder(args, src_dict)\n return encoder\n\n @classmethod\n def build_decoder(cls, args, src_dict, dst_dict):\n \"\"\"Build a new (multi-)decoder instance.\"\"\"\n if args.multi_decoder is not None:\n ngram_decoder_args = [None] * args.multi_decoder\n if args.ngram_decoder is not None:\n ngram_decoder_args = args.ngram_decoder\n if len(ngram_decoder_args) == 1:\n ngram_decoder_args = [ngram_decoder_args[0]] * args.multi_decoder\n assert len(ngram_decoder_args) == args.multi_decoder\n is_lm_args = [False] * args.multi_decoder\n if args.multi_decoder_is_lm is not None:\n is_lm_args = list(map(bool, args.multi_decoder_is_lm))\n assert len(is_lm_args) == args.multi_decoder\n decoders = [\n RNNModel.build_single_decoder(\n args, src_dict, dst_dict, n, project_output=False, is_lm=is_lm\n )\n for is_lm, n in zip(is_lm_args, ngram_decoder_args)\n ]\n decoder = MultiDecoder(\n src_dict,\n dst_dict,\n decoders=decoders,\n combination_strategy=args.multi_decoder_combination_strategy,\n is_lm=is_lm_args,\n split_encoder=args.multi_encoder is not None,\n vocab_reduction_params=args.vocab_reduction_params,\n training_schedule=args.multi_model_training_schedule,\n fixed_weights=args.multi_model_fixed_weights,\n )\n else:\n if args.multi_encoder:\n args.encoder_hidden_dim *= args.multi_encoder\n n = args.ngram_decoder[0] if args.ngram_decoder else None\n decoder = RNNModel.build_single_decoder(args, src_dict, dst_dict, n)\n return decoder\n\n @classmethod\n def build_model(cls, args, task):\n \"\"\"Build a new model instance.\"\"\"\n base_architecture(args)\n # set default value for old checkpoints\n args.left_pad_source = getattr(args, \"left_pad_source\", True)\n if pytorch_translate_data.is_multilingual(args):\n return RNNModel.build_model_multilingual(args, task)\n src_dict, dst_dict = task.source_dictionary, task.target_dictionary\n encoder = RNNModel.build_encoder(args, src_dict)\n decoder = RNNModel.build_decoder(args, src_dict, dst_dict)\n return cls(task, encoder, decoder)\n\n @classmethod\n def build_model_multilingual(cls, args, task):\n \"\"\"Build a new multilingual model instance.\"\"\"\n encoders = []\n for lang in args.multiling_encoder_lang:\n d = task.source_dictionaries.get(lang, None)\n if d is not None:\n encoders.append(RNNModel.build_encoder(args, d))\n else:\n encoders.append(None)\n encoder = MultilingualEncoder(\n task.source_dictionary,\n encoders,\n hidden_dim=args.encoder_hidden_dim,\n num_layers=args.encoder_layers,\n embed_dim=args.encoder_embed_dim,\n rescale_grads=args.multiling_rescale_grads,\n )\n decoders = []\n for lang in args.multiling_decoder_lang:\n d = task.target_dictionaries.get(lang, None)\n if d is not None:\n decoders.append(RNNModel.build_decoder(args, None, d))\n else:\n decoders.append(None)\n decoder = MultilingualDecoder(\n task.target_dictionary,\n decoders,\n hidden_dim=args.encoder_hidden_dim,\n rescale_grads=args.multiling_rescale_grads,\n )\n return cls(task, encoder, decoder)\n\n def get_targets(self, sample, net_output):\n targets = sample[\"target\"].view(-1)\n possible_translation_tokens = net_output[-1]\n if possible_translation_tokens is not None:\n targets = torch_find(\n possible_translation_tokens, targets, len(self.task.target_dictionary)\n )\n return targets\n\n\nclass LSTMSequenceEncoder(FairseqEncoder):\n \"\"\"RNN encoder using nn.LSTM for cuDNN support / ONNX exportability.\"\"\"\n\n @staticmethod\n def LSTM(input_size, hidden_size, **kwargs):\n m = nn.LSTM(input_size, hidden_size, **kwargs)\n for name, param in m.named_parameters():\n if \"weight\" in name or \"bias\" in name:\n param.data.uniform_(-0.1, 0.1)\n return m\n\n def __init__(\n self,\n dictionary,\n embed_dim=512,\n freeze_embed=False,\n cell_type=\"lstm\",\n hidden_dim=512,\n num_layers=1,\n dropout_in=0.1,\n dropout_out=0.1,\n residual_level=None,\n bidirectional=False,\n pretrained_embed=None,\n word_dropout_params=None,\n padding_value=0,\n left_pad=True,\n ):\n assert cell_type == \"lstm\", 'sequence-lstm requires cell_type=\"lstm\"'\n\n super().__init__(dictionary)\n self.dictionary = dictionary\n self.dropout_in = dropout_in\n self.dropout_out = dropout_out\n self.residual_level = residual_level\n self.hidden_dim = hidden_dim\n self.bidirectional = bidirectional\n num_embeddings = len(dictionary)\n self.padding_idx = dictionary.pad()\n self.padding_value = padding_value\n self.left_pad = left_pad\n\n self.embed_tokens = Embedding(\n num_embeddings=num_embeddings,\n embedding_dim=embed_dim,\n padding_idx=self.padding_idx,\n freeze_embed=freeze_embed,\n )\n pytorch_translate_utils.load_embedding(\n embedding=self.embed_tokens,\n dictionary=dictionary,\n pretrained_embed=pretrained_embed,\n )\n self.word_dim = embed_dim\n\n self.layers = nn.ModuleList([])\n for layer in range(num_layers):\n is_layer_bidirectional = self.bidirectional and layer == 0\n self.layers.append(\n LSTMSequenceEncoder.LSTM(\n self.word_dim if layer == 0 else hidden_dim,\n hidden_dim // 2 if is_layer_bidirectional else hidden_dim,\n num_layers=1,\n dropout=self.dropout_out,\n bidirectional=is_layer_bidirectional,\n )\n )\n\n self.num_layers = len(self.layers)\n self.word_dropout_module = None\n if (\n word_dropout_params\n and word_dropout_params[\"word_dropout_freq_threshold\"] is not None\n and word_dropout_params[\"word_dropout_freq_threshold\"] > 0\n ):\n self.word_dropout_module = word_dropout.WordDropout(\n dictionary, word_dropout_params\n )\n\n # Variable tracker\n self.tracker = VariableTracker()\n\n # Initialize adversarial mode\n self.set_gradient_tracking_mode(False)\n\n def forward(self, src_tokens, src_lengths):\n if self.left_pad:\n # convert left-padding to right-padding\n src_tokens = utils.convert_padding_direction(\n src_tokens, self.padding_idx, left_to_right=True\n )\n\n # If we're generating adversarial examples we need to keep track of\n # some internal variables\n self.tracker.reset()\n\n if self.word_dropout_module is not None:\n src_tokens = self.word_dropout_module(src_tokens)\n\n bsz, seqlen = src_tokens.size()\n\n # embed tokens\n x = self.embed_tokens(src_tokens)\n # Track token embeddings\n self.tracker.track(x, \"token_embeddings\", retain_grad=self.track_gradients)\n\n x = F.dropout(x, p=self.dropout_in, training=self.training)\n\n # B x T x C -> T x B x C\n x = x.transpose(0, 1)\n embedded_words = x\n\n # Allows compatibility with Caffe2 inputs for tracing (int32)\n # as well as the current format of Fairseq-Py inputs (int64)\n if src_lengths.dtype is torch.int64:\n src_lengths = src_lengths.int()\n\n # Generate packed seq to deal with varying source seq length\n # packed_input is of type PackedSequence, which consists of:\n # element [0]: a tensor, the packed data, and\n # element [1]: a list of integers, the batch size for each step\n packed_input = pack_padded_sequence(x, src_lengths)\n\n final_hiddens, final_cells = [], []\n for i, rnn_layer in enumerate(self.layers):\n if self.bidirectional and i == 0:\n h0 = x.new(2, bsz, self.hidden_dim // 2).zero_()\n c0 = x.new(2, bsz, self.hidden_dim // 2).zero_()\n else:\n h0 = x.new(1, bsz, self.hidden_dim).zero_()\n c0 = x.new(1, bsz, self.hidden_dim).zero_()\n\n # apply LSTM along entire sequence\n current_output, (h_last, c_last) = rnn_layer(packed_input, (h0, c0))\n\n # final state shapes: (bsz, hidden_dim)\n if self.bidirectional and i == 0:\n # concatenate last states for forward and backward LSTM\n h_last = torch.cat((h_last[0, :, :], h_last[1, :, :]), dim=1)\n c_last = torch.cat((c_last[0, :, :], c_last[1, :, :]), dim=1)\n else:\n h_last = h_last.squeeze(dim=0)\n c_last = c_last.squeeze(dim=0)\n\n final_hiddens.append(h_last)\n final_cells.append(c_last)\n\n if self.residual_level is not None and i >= self.residual_level:\n packed_input[0] = packed_input.clone()[0] + current_output[0]\n else:\n packed_input = current_output\n\n # Reshape to [num_layer, batch_size, hidden_dim]\n final_hiddens = torch.cat(final_hiddens, dim=0).view(\n self.num_layers, *final_hiddens[0].size()\n )\n final_cells = torch.cat(final_cells, dim=0).view(\n self.num_layers, *final_cells[0].size()\n )\n\n # [max_seqlen, batch_size, hidden_dim]\n unpacked_output, _ = pad_packed_sequence(\n packed_input, padding_value=self.padding_value\n )\n\n return (\n unpacked_output,\n final_hiddens,\n final_cells,\n src_lengths,\n src_tokens,\n embedded_words,\n )\n\n def reorder_encoder_out(self, encoder_out, new_order):\n \"\"\"Reorder all outputs according to new_order.\"\"\"\n return reorder_encoder_output(encoder_out, new_order)\n\n def max_positions(self):\n \"\"\"Maximum input length supported by the encoder.\"\"\"\n return int(1e5) # an arbitrary large number\n\n def set_gradient_tracking_mode(self, mode=True):\n self.tracker.reset()\n self.track_gradients = mode\n\n\nclass DummyEncoder(FairseqEncoder):\n \"\"\"Dummy encoder which outputs None. Used for LM training.\"\"\"\n\n def __init__(self, dictionary, num_layers=1):\n super().__init__(dictionary)\n self.num_layers = num_layers\n\n def forward(self, src_tokens, src_lengths):\n bsz = src_lengths.size(0)\n ones = maybe_cuda(torch.ones((self.num_layers, bsz, 1)))\n dummy_out = torch.ones((1, bsz, 1))\n return dummy_out, ones, ones, src_lengths, src_tokens, dummy_out\n\n def max_positions(self):\n \"\"\"Maximum input length supported by the encoder.\"\"\"\n return int(1e5) # an arbitrary large number\n\n\nclass RNNEncoder(FairseqEncoder):\n \"\"\"RNN encoder.\"\"\"\n\n def __init__(\n self,\n dictionary,\n word_dropout_params=None,\n embed_dim=512,\n freeze_embed=False,\n hidden_dim=512,\n num_layers=1,\n cell_type=\"lstm\",\n dropout_in=0.1,\n dropout_out=0.1,\n residual_level=None,\n bidirectional=False,\n pretrained_embed=None,\n padding_value=0,\n left_pad=True,\n ):\n super().__init__(dictionary)\n self.dictionary = dictionary\n self.dropout_in = dropout_in\n self.dropout_out = dropout_out\n self.residual_level = residual_level\n self.hidden_dim = hidden_dim\n self.output_units = hidden_dim # fairseq LSTM compatibility\n self.bidirectional = bidirectional\n num_embeddings = len(dictionary)\n self.padding_idx = dictionary.pad()\n self.padding_value = padding_value\n self.left_pad = left_pad\n\n self.embed_tokens = Embedding(\n num_embeddings=num_embeddings,\n embedding_dim=embed_dim,\n padding_idx=self.padding_idx,\n freeze_embed=freeze_embed,\n )\n pytorch_translate_utils.load_embedding(\n embedding=self.embed_tokens,\n dictionary=dictionary,\n pretrained_embed=pretrained_embed,\n )\n self.word_dim = embed_dim\n\n self.cell_type = cell_type\n self.layers = nn.ModuleList([])\n for layer in range(num_layers):\n self.layers.append(\n RNNLayer(\n self.word_dim if layer == 0 else hidden_dim,\n hidden_dim,\n self.cell_type,\n True if bidirectional and layer == 0 else False,\n )\n )\n\n self.num_layers = len(self.layers)\n self.word_dropout_module = None\n if (\n word_dropout_params\n and word_dropout_params[\"word_dropout_freq_threshold\"] is not None\n and word_dropout_params[\"word_dropout_freq_threshold\"] > 0\n ):\n self.word_dropout_module = word_dropout.WordDropout(\n dictionary, word_dropout_params\n )\n\n def forward(self, src_tokens, src_lengths):\n if self.left_pad:\n # convert left-padding to right-padding\n src_tokens = utils.convert_padding_direction(\n src_tokens, self.padding_idx, left_to_right=True\n )\n if self.word_dropout_module is not None:\n src_tokens = self.word_dropout_module(src_tokens)\n bsz, seqlen = src_tokens.size()\n\n # embed tokens\n x = self.embed_tokens(src_tokens)\n x = F.dropout(x, p=self.dropout_in, training=self.training)\n\n # B x T x C -> T x B x C\n x = x.transpose(0, 1)\n embedded_words = x\n\n # Generate packed seq to deal with varying source seq length\n packed_input, batch_sizes = pack_padded_sequence(x, src_lengths)\n final_hiddens, final_cells = [], []\n next_hiddens = []\n for i, rnn_layer in enumerate(self.layers):\n current_hidden_size = (\n self.hidden_dim // 2 if rnn_layer.is_bidirectional else self.hidden_dim\n )\n\n if self.cell_type in [\"lstm\", \"milstm\", \"layer_norm_lstm\"]:\n prev_hidden = (\n x.new(bsz, current_hidden_size).zero_(),\n x.new(bsz, current_hidden_size).zero_(),\n )\n else:\n raise Exception(f\"{self.cell_type} not implemented\")\n\n hidden, current_output = rnn_layer.forward(\n packed_input, prev_hidden, batch_sizes\n )\n next_hiddens.append(hidden)\n prev_hidden = next_hiddens[-1]\n\n if self.dropout_out != 0:\n current_output = F.dropout(\n current_output, p=self.dropout_out, training=self.training\n )\n\n if self.residual_level is not None and i >= self.residual_level:\n packed_input = packed_input.clone() + current_output\n else:\n packed_input = current_output\n\n final_hiddens, final_cells = zip(*next_hiddens)\n # Reshape to [num_layer, batch_size, hidden_dim]\n final_hiddens = torch.cat(final_hiddens, dim=0).view(\n self.num_layers, *final_hiddens[0].size()\n )\n final_cells = torch.cat(final_cells, dim=0).view(\n self.num_layers, *final_cells[0].size()\n )\n\n # [max_seqlen, batch_size, hidden_dim]\n unpacked_output, _ = pad_packed_sequence(\n PackedSequence(packed_input, batch_sizes), padding_value=self.padding_value\n )\n\n return (\n unpacked_output,\n final_hiddens,\n final_cells,\n src_lengths,\n src_tokens,\n embedded_words,\n )\n\n def reorder_encoder_out(self, encoder_out, new_order):\n \"\"\"Reorder all outputs according to new_order.\"\"\"\n return reorder_encoder_output(encoder_out, new_order)\n\n def max_positions(self):\n \"\"\"Maximum input length supported by the encoder.\"\"\"\n return int(1e5) # an arbitrary large number\n\n\nclass RNNDecoder(DecoderWithOutputProjection):\n \"\"\"RNN decoder.\"\"\"\n\n def __init__(\n self,\n src_dict,\n dst_dict,\n vocab_reduction_params=None,\n encoder_hidden_dim=512,\n embed_dim=512,\n freeze_embed=False,\n hidden_dim=512,\n out_embed_dim=512,\n cell_type=\"lstm\",\n num_layers=1,\n dropout_in=0.1,\n dropout_out=0.1,\n attention_type=\"dot\",\n residual_level=None,\n averaging_encoder=False,\n project_output=True,\n tie_embeddings=False,\n pretrained_embed=None,\n projection_pretrained_embed=None,\n att_weighted_src_embeds=False,\n src_embed_dim=512,\n att_weighted_activation_type=\"tanh\",\n ):\n super().__init__(\n src_dict,\n dst_dict,\n vocab_reduction_params,\n out_embed_dim,\n project_output=project_output,\n pretrained_embed=projection_pretrained_embed,\n att_weighted_src_embeds=att_weighted_src_embeds,\n src_embed_dim=src_embed_dim,\n att_weighted_activation_type=att_weighted_activation_type,\n )\n encoder_hidden_dim = max(1, encoder_hidden_dim)\n self.encoder_hidden_dim = encoder_hidden_dim\n self.embed_dim = embed_dim\n self.hidden_dim = hidden_dim\n self.out_embed_dim = out_embed_dim\n self.dropout_in = dropout_in\n self.dropout_out = dropout_out\n self.attention_type = attention_type\n self.residual_level = residual_level\n self.tie_embeddings = tie_embeddings\n\n num_embeddings = len(dst_dict)\n padding_idx = dst_dict.pad()\n self.embed_tokens = Embedding(\n num_embeddings=num_embeddings,\n embedding_dim=embed_dim,\n padding_idx=padding_idx,\n freeze_embed=freeze_embed,\n )\n if self.tie_embeddings:\n assert self.embed_dim == self.out_embed_dim, (\n \"Input embeddings and output projections must have the same \"\n \"dimension for the weights to be tied\"\n )\n self.embed_tokens.weight = self.output_projection_w\n else:\n pytorch_translate_utils.load_embedding(\n embedding=self.embed_tokens,\n dictionary=dst_dict,\n pretrained_embed=pretrained_embed,\n )\n\n self.hidden_dim = hidden_dim\n self.averaging_encoder = averaging_encoder\n\n if cell_type == \"lstm\":\n cell_class = rnn_cell.LSTMCell\n elif cell_type == \"milstm\":\n cell_class = rnn_cell.MILSTMCell\n elif cell_type == \"layer_norm_lstm\":\n cell_class = rnn_cell.LayerNormLSTMCell\n\n if hidden_dim != encoder_hidden_dim:\n hidden_init_fc_list = []\n cell_init_fc_list = []\n for _ in range(num_layers):\n hidden_init_fc_list.append(Linear(encoder_hidden_dim, hidden_dim))\n cell_init_fc_list.append(Linear(encoder_hidden_dim, hidden_dim))\n self.hidden_init_fc_list = nn.ModuleList(hidden_init_fc_list)\n self.cell_init_fc_list = nn.ModuleList(cell_init_fc_list)\n\n self.attention = attention.build_attention(\n attention_type=attention_type,\n decoder_hidden_state_dim=hidden_dim,\n context_dim=encoder_hidden_dim,\n )\n if self.attention.context_dim:\n self.initial_attn_context = nn.Parameter(\n torch.Tensor(self.attention.context_dim).zero_()\n )\n self.combined_output_and_context_dim = self.attention.context_dim + hidden_dim\n\n layers = []\n for layer in range(num_layers):\n if layer == 0:\n cell_input_dim = embed_dim + self.attention.context_dim\n else:\n cell_input_dim = hidden_dim\n layers.append(cell_class(input_dim=cell_input_dim, hidden_dim=hidden_dim))\n self.layers = nn.ModuleList(layers)\n\n if self.combined_output_and_context_dim != out_embed_dim:\n self.additional_fc = Linear(\n self.combined_output_and_context_dim, out_embed_dim\n )\n\n def forward_unprojected(self, input_tokens, encoder_out, incremental_state=None):\n if incremental_state is not None:\n input_tokens = input_tokens[:, -1:]\n bsz, seqlen = input_tokens.size()\n\n # get outputs from encoder\n (\n encoder_outs,\n final_hidden,\n final_cell,\n src_lengths,\n src_tokens,\n _,\n ) = encoder_out\n\n # embed tokens\n x = self.embed_tokens(input_tokens)\n x = F.dropout(x, p=self.dropout_in, training=self.training)\n # B x T x C -> T x B x C\n x = x.transpose(0, 1)\n\n # initialize previous states (or get from cache during incremental generation)\n cached_state = utils.get_incremental_state(\n self, incremental_state, \"cached_state\"\n )\n input_feed = None\n if cached_state is not None:\n prev_hiddens, prev_cells, input_feed = cached_state\n else:\n # first time step, initialize previous states\n init_prev_states = self._init_prev_states(encoder_out)\n prev_hiddens = []\n prev_cells = []\n\n # init_prev_states may or may not include initial attention context\n for (h, c) in zip(init_prev_states[0::2], init_prev_states[1::2]):\n prev_hiddens.append(h)\n prev_cells.append(c)\n if self.attention.context_dim:\n input_feed = self.initial_attn_context.expand(\n bsz, self.attention.context_dim\n )\n\n attn_scores_per_step = []\n outs = []\n for j in range(seqlen):\n # input feeding: concatenate context vector from previous time step\n step_input = maybe_cat((x[j, :, :], input_feed), dim=1)\n previous_layer_input = step_input\n for i, rnn in enumerate(self.layers):\n # recurrent cell\n hidden, cell = rnn(step_input, (prev_hiddens[i], prev_cells[i]))\n\n # hidden state becomes the input to the next layer\n layer_output = F.dropout(\n hidden, p=self.dropout_out, training=self.training\n )\n\n if self.residual_level is not None and i >= self.residual_level:\n # TODO add an assert related to sizes here\n step_input = layer_output + previous_layer_input\n else:\n step_input = layer_output\n previous_layer_input = step_input\n\n # save state for next time step\n prev_hiddens[i] = hidden\n prev_cells[i] = cell\n\n out, step_attn_scores = self.attention(hidden, encoder_outs, src_lengths)\n input_feed = out\n attn_scores_per_step.append(step_attn_scores.unsqueeze(1))\n attn_scores = torch.cat(attn_scores_per_step, dim=1)\n # srclen x tgtlen x bsz -> bsz x tgtlen x srclen\n attn_scores = attn_scores.transpose(0, 2)\n combined_output_and_context = maybe_cat((hidden, out), dim=1)\n\n # save final output\n outs.append(combined_output_and_context)\n\n # cache previous states (no-op except during incremental generation)\n utils.set_incremental_state(\n self,\n incremental_state,\n \"cached_state\",\n (prev_hiddens, prev_cells, input_feed),\n )\n\n # collect outputs across time steps\n x = torch.cat(outs, dim=0).view(\n seqlen, bsz, self.combined_output_and_context_dim\n )\n\n # T x B x C -> B x T x C\n x = x.transpose(1, 0)\n\n # bottleneck layer\n if hasattr(self, \"additional_fc\"):\n x = self.additional_fc(x)\n x = F.dropout(x, p=self.dropout_out, training=self.training)\n return x, attn_scores\n\n def reorder_incremental_state(self, incremental_state, new_order):\n \"\"\"Reorder buffered internal state (for incremental generation).\"\"\"\n cached_state = utils.get_incremental_state(\n self, incremental_state, \"cached_state\"\n )\n if cached_state is None:\n return\n\n def reorder_state(state):\n if state is None:\n return None\n if isinstance(state, list):\n return [reorder_state(state_i) for state_i in state]\n return state.index_select(0, new_order)\n\n new_state = tuple(map(reorder_state, cached_state))\n utils.set_incremental_state(self, incremental_state, \"cached_state\", new_state)\n\n def max_positions(self):\n \"\"\"Maximum output length supported by the decoder.\"\"\"\n return int(1e5) # an arbitrary large number\n\n def _init_prev_states(self, encoder_out):\n (\n encoder_output,\n final_hiddens,\n final_cells,\n src_lengths,\n src_tokens,\n _,\n ) = encoder_out\n num_layers = len(self.layers)\n if self.averaging_encoder:\n # Use mean encoder hidden states\n prev_hiddens = [torch.mean(encoder_output, 0)] * num_layers\n else:\n # Simply return the final state of each layer\n prev_hiddens = [final_hiddens[i] for i in range(num_layers)]\n prev_cells = [final_cells[i] for i in range(num_layers)]\n\n if hasattr(self, \"hidden_init_fc_list\"):\n for i in range(num_layers):\n prev_hiddens[i] = self.hidden_init_fc_list[i](prev_hiddens[i])\n prev_cells[i] = self.cell_init_fc_list[i](prev_cells[i])\n\n prev_states = []\n for h, c in zip(prev_hiddens, prev_cells):\n prev_states.extend([h, c])\n if self.attention.context_dim:\n prev_states.append(self.initial_attn_context)\n\n return prev_states\n\n\n@register_model_architecture(\"rnn\", \"rnn\")\ndef base_architecture(args):\n # default architecture\n args.encoder_embed_dim = getattr(args, \"encoder_embed_dim\", 512)\n args.encoder_layers = getattr(args, \"encoder_layers\", 1)\n args.encoder_hidden_dim = getattr(args, \"encoder_hidden_dim\", 512)\n args.encoder_bidirectional = getattr(args, \"encoder_bidirectional\", False)\n args.encoder_dropout_in = getattr(args, \"encoder_dropout_in\", args.dropout)\n args.encoder_dropout_out = getattr(args, \"encoder_dropout_out\", args.dropout)\n args.encoder_pretrained_embed = getattr(args, \"encoder_pretrained_embed\", None)\n args.decoder_embed_dim = getattr(args, \"decoder_embed_dim\", 512)\n args.decoder_layers = getattr(args, \"decoder_layers\", 1)\n args.decoder_hidden_dim = getattr(args, \"decoder_hidden_dim\", 512)\n args.decoder_pretrained_embed = getattr(args, \"decoder_pretrained_embed\", None)\n args.decoder_out_embed_dim = getattr(args, \"decoder_out_embed_dim\", 512)\n args.decoder_out_pretrained_embed = getattr(\n args, \"decoder_out_pretrained_embed\", None\n )\n args.attention_type = getattr(args, \"attention_type\", \"dot\")\n args.decoder_dropout_in = getattr(args, \"decoder_dropout_in\", args.dropout)\n args.decoder_dropout_out = getattr(args, \"decoder_dropout_out\", args.dropout)\n args.averaging_encoder = getattr(args, \"averaging_encoder\", False)\n args.encoder_freeze_embed = getattr(args, \"encoder_freeze_embed\", False)\n args.decoder_freeze_embed = getattr(args, \"decoder_freeze_embed\", False)\n args.ngram_decoder = getattr(args, \"ngram_decoder\", None)\n args.multi_encoder = getattr(args, \"multi_encoder\", None)\n args.multi_decoder = getattr(args, \"multi_decoder\", None)\n args.multi_decoder_is_lm = getattr(args, \"multi_decoder_is_lm\", None)\n args.multiling_encoder_lang = getattr(args, \"multiling_encoder_lang\", None)\n args.multi_model_training_schedule = getattr(\n args, \"multi_model_training_schedule\", \"complete\"\n )\n args.multi_model_fixed_weights = getattr(args, \"multi_model_fixed_weights\", None)\n args.cell_type = getattr(args, \"cell_type\", \"lstm\")\n args.ngram_activation_type = getattr(args, \"ngram_activation_type\", \"relu\")\n vocab_reduction.set_arg_defaults(args)\n word_dropout.set_arg_defaults(args)\n args.sequence_lstm = getattr(args, \"sequence_lstm\", False)\n args.decoder_tie_embeddings = getattr(args, \"decoder_tie_embeddings\", False)\n args.encoder_pretrained_embed = getattr(args, \"encoder_pretrained_embed\", None)\n args.decoder_pretrained_embed = getattr(args, \"decoder_pretrained_embed\", None)\n args.decoder_out_pretrained_embed = getattr(\n args, \"decoder_out_pretrained_embed\", None\n )\n args.att_weighted_src_embeds = getattr(args, \"att_weighted_source_embeds\", False)\n args.att_weighted_activation_type = getattr(\n args, \"att_weighted_activation_type\", \"tanh\"\n )\n\n@register_model_architecture(\"rnn\", \"rnn_big_test\")\ndef rnn_big_test(args):\n base_architecture(args)\n args.encoder_embed_dim = 1024\n args.encoder_layers = 6\n args.encoder_hidden_dim = 1024\n args.decoder_embed_dim = 1024\n args.decoder_layers = 6\n args.decoder_hidden_dim = 1024\n args.decoder_out_embed_dim = 1024\n"
] | [
[
"torch.ones",
"torch.nn.LSTM",
"torch.Tensor",
"torch.nn.utils.rnn.pack_padded_sequence",
"torch.nn.functional.dropout",
"torch.nn.utils.rnn.PackedSequence",
"torch.arange",
"torch.nn.ModuleList",
"torch.zeros",
"torch.cat",
"torch.nn.utils.rnn.pad_packed_sequence",
"torch.mean"
]
] |
remo-rcm/pyremo2 | [
"59bd18d411944205db93c062439172f91ba99f83"
] | [
"pyremo/core/exp.py"
] | [
"\"\"\"Module for working and parsing Remo output files.\n\"\"\"\nimport os\nfrom pathlib import Path\n\nimport pandas as pd\nimport parse\nfrom tqdm import tqdm\n\nfile_pattern = \"e{usr_nr:3d}{exp_nr:3d}{type:1}{date}\"\nefile_pattern = \"e{usr_nr:3d}{exp_nr:3d}{type:1}_c{code:3d}_{date}\"\n\ndate_patterns = [\"%Y\", \"%Y%m\", \"%Y%m%d\", \"%Y%m%d\", \"%Y%m%d%H\", \"%Y%m%d%H%M\"]\n\npatterns = [efile_pattern, file_pattern]\n\n\ndef _find_files(dir, file_template=\"e*\", exclude=None):\n \"\"\"search a directory for remo output.\"\"\"\n pattern = file_template\n return [path.absolute() for path in Path(dir).rglob(pattern)]\n\n\ndef _parse_file(file):\n for pattern in patterns:\n finfo = parse.parse(pattern, file)\n if finfo:\n return finfo.named\n\n\ndef get_data_catalog(dir, parse_dates=False, exclude=None):\n filepathes = _find_files(dir, exclude=exclude)\n df_all = pd.DataFrame()\n for path in tqdm(filepathes):\n finfo = _parse_file(path.stem)\n if finfo is None:\n print(\"could not parse: \", path.stem)\n continue\n finfo[\"path\"] = str(path)\n finfo[\"suffix\"] = path.suffix\n df = pd.DataFrame(finfo, index=[0])\n if parse_dates:\n for dpat in date_patterns:\n try:\n df[\"date\"] = pd.to_datetime(df.date, format=dpat)\n break\n except Exception:\n pass\n df_all = df_all.append(df, ignore_index=True)\n try:\n df_all[\"code\"] = df_all.code.astype(pd.Int64Dtype())\n except Exception:\n pass\n return df_all\n\n\ndef move_data(sdir, tdir, **kwargs):\n \"\"\"move remo data according to type to different directories\"\"\"\n\n efile_dir = os.path.join(tdir, \"xe\")\n tfile_dir = os.path.join(tdir, \"xt\")\n ffile_dir = os.path.join(tdir, \"xf\")\n\n for dir in [efile_dir, tfile_dir, ffile_dir]:\n try:\n os.makedirs(dir)\n except Exception:\n print(\"Directory exists: {}\".format(dir))\n\n return get_data_catalog(tdir)\n\n\nclass RemoExpData:\n def __init__(self):\n pass\n"
] | [
[
"pandas.to_datetime",
"pandas.Int64Dtype",
"pandas.DataFrame"
]
] |
LemonLison/pystruct | [
"23c6d8f6ab34a88b63386a595debbfdfa13345fe"
] | [
"pystruct/learners/n_slack_ssvm.py"
] | [
"######################\n# (c) 2012 Andreas Mueller <[email protected]>\n# License: BSD 3-clause\n#\n# Implements structured SVM as described in Tsochantaridis et. al.\n# Support Vector Machines Learning for Interdependent\n# and Structures Output Spaces\n\nfrom time import time\n\nimport numpy as np\nimport cvxopt\nimport cvxopt.solvers\n\nfrom sklearn.externals.joblib import Parallel, delayed\nfrom sklearn.utils import gen_even_slices\n\nfrom .ssvm import BaseSSVM\nfrom ..utils import unwrap_pairwise, find_constraint\n\n\nclass NSlackSSVM(BaseSSVM):\n \"\"\"Structured SVM solver for the n-slack QP with l1 slack penalty.\n\n Implements margin rescaled structural SVM using\n the n-slack formulation and cutting plane method, solved using CVXOPT.\n The optimization is restarted in each iteration.\n\n Parameters\n ----------\n model : StructuredModel\n Object containing the model structure. Has to implement\n `loss`, `inference` and `loss_augmented_inference`.\n\n max_iter : int\n Maximum number of passes over dataset to find constraints.\n\n C : float\n Regularization parameter\n\n check_constraints : bool (default=True)\n Whether to check if the new \"most violated constraint\" is\n more violated than previous constraints. Helpful for stopping\n and debugging, but costly.\n\n verbose : int (default=0)\n Verbosity.\n\n negativity_constraint: list of ints\n Indices of parmeters that are constraint to be negative.\n This is useful for learning submodular CRFs (inference is formulated\n as maximization in SSVMs, flipping some signs).\n\n break_on_bad: bool (default=False)\n Whether to break (start debug mode) when inference was approximate.\n\n n_jobs : int, default=1\n Number of parallel jobs for inference. -1 means as many as cpus.\n\n show_loss_every : int, default=0\n Controlls how often the hamming loss is computed (for monitoring\n purposes). Zero means never, otherwise it will be computed very\n show_loss_every'th epoch.\n\n batch_size : int, default=100\n Number of constraints after which we solve the QP again.\n batch_size=-1 means that an update is performed only after going once\n over the whole training set.\n\n tol : float, default=-10\n Convergence tolerance. If dual objective decreases less than tol,\n learning is stopped. The default corresponds to ignoring the behavior\n of the dual objective and stop only if no more constraints can be\n found.\n\n inactive_threshold : float, default=1e-5\n Threshold for dual variable of a constraint to be considered inactive.\n\n inactive_window : float, default=50\n Window for measuring inactivity. If a constraint is inactive for\n ``inactive_window`` iterations, it will be pruned from the QP.\n If set to 0, no constraints will be removed.\n\n switch_to : None or string, default=None\n Switch to the given inference method if the previous method does not\n find any more constraints.\n\n logger : logger object, default=None\n Pystruct logger for storing the model or extracting additional\n information.\n\n Attributes\n ----------\n w : nd-array, shape=(model.size_joint_feature,)\n The learned weights of the SVM.\n\n old_solution : dict\n The last solution found by the qp solver.\n\n ``loss_curve_`` : list of float\n List of loss values if show_loss_every > 0.\n\n ``objective_curve_`` : list of float\n Cutting plane objective after each pass through the dataset.\n\n ``primal_objective_curve_`` : list of float\n Primal objective after each pass through the dataset.\n\n ``timestamps_`` : list of int\n Total training time stored before each iteration.\n\n References\n ----------\n * Tsochantaridis, Ioannis and Joachims, Thorsten and Hofmann, Thomas and\n Altun, Yasemin and Singer, Yoram: Large margin methods for structured\n and interdependent output variables, JMLR 2006\n\n * Joachims, Thorsten and Finley, Thomas and Yu, Chun-Nam John:\n Cutting-plane training of structural SVMs, JMLR 2009\n \"\"\"\n\n def __init__(self, model, max_iter=100, C=1.0, check_constraints=True,\n verbose=0, negativity_constraint=None, n_jobs=1,\n break_on_bad=False, show_loss_every=0, batch_size=100,\n tol=1e-3, inactive_threshold=1e-5,\n inactive_window=50, logger=None, switch_to=None):\n\n BaseSSVM.__init__(self, model, max_iter, C, verbose=verbose,\n n_jobs=n_jobs, show_loss_every=show_loss_every,\n logger=logger)\n\n self.negativity_constraint = negativity_constraint\n self.check_constraints = check_constraints\n self.break_on_bad = break_on_bad\n self.batch_size = batch_size\n self.tol = tol\n self.inactive_threshold = inactive_threshold\n self.inactive_window = inactive_window\n self.switch_to = switch_to\n\n def _solve_n_slack_qp(self, constraints, n_samples):\n C = self.C\n joint_features = [c[1] for sample in constraints for c in sample]\n losses = [c[2] for sample in constraints for c in sample]\n\n joint_feature_matrix = np.vstack(joint_features).astype(np.float)\n n_constraints = len(joint_features)\n P = cvxopt.matrix(np.dot(joint_feature_matrix, joint_feature_matrix.T))\n # q contains loss from margin-rescaling\n q = cvxopt.matrix(-np.array(losses, dtype=np.float))\n # constraints are a bit tricky. first, all alpha must be >zero\n idy = np.identity(n_constraints)\n tmp1 = np.zeros(n_constraints)\n # box constraint: sum of all alpha for one example must be <= C\n blocks = np.zeros((n_samples, n_constraints))\n first = 0\n for i, sample in enumerate(constraints):\n blocks[i, first: first + len(sample)] = 1\n first += len(sample)\n # positivity constraints:\n if self.negativity_constraint is None:\n #empty constraints\n zero_constr = np.zeros(0)\n joint_features_constr = np.zeros((0, n_constraints))\n else:\n joint_features_constr = joint_feature_matrix.T[self.negativity_constraint]\n zero_constr = np.zeros(len(self.negativity_constraint))\n\n # put together\n G = cvxopt.sparse(cvxopt.matrix(np.vstack((-idy, blocks,\n joint_features_constr))))\n tmp2 = np.ones(n_samples) * C\n h = cvxopt.matrix(np.hstack((tmp1, tmp2, zero_constr)))\n\n # solve QP model\n cvxopt.solvers.options['feastol'] = 1e-5\n try:\n solution = cvxopt.solvers.qp(P, q, G, h)\n except ValueError:\n solution = {'status': 'error'}\n if solution['status'] != \"optimal\":\n print(\"regularizing QP!\")\n P = cvxopt.matrix(np.dot(joint_feature_matrix, joint_feature_matrix.T)\n + 1e-8 * np.eye(joint_feature_matrix.shape[0]))\n solution = cvxopt.solvers.qp(P, q, G, h)\n if solution['status'] != \"optimal\":\n raise ValueError(\"QP solver failed. Try regularizing your QP.\")\n\n # Lagrange multipliers\n a = np.ravel(solution['x'])\n self.prune_constraints(constraints, a)\n self.old_solution = solution\n\n # Support vectors have non zero lagrange multipliers\n sv = a > self.inactive_threshold * C\n box = np.dot(blocks, a)\n if self.verbose > 1:\n print(\"%d support vectors out of %d points\" % (np.sum(sv),\n n_constraints))\n # calculate per example box constraint:\n print(\"Box constraints at C: %d\" % np.sum(1 - box / C < 1e-3))\n print(\"dual objective: %f\" % -solution['primal objective'])\n self.w = np.dot(a, joint_feature_matrix)\n return -solution['primal objective']\n\n def _check_bad_constraint(self, y_hat, slack, old_constraints):\n if slack < 1e-5:\n return True\n y_hat_plain = unwrap_pairwise(y_hat)\n\n already_active = np.any([True for y__, _, _ in old_constraints\n if np.all(y_hat_plain ==\n unwrap_pairwise(y__))])\n if already_active:\n return True\n\n # \"smart\" stopping criterion\n # check if most violated constraint is more violated\n # than previous ones by more then eps.\n # If it is less violated, inference was wrong/approximate\n if self.check_constraints:\n for con in old_constraints:\n # compute slack for old constraint\n slack_tmp = max(con[2] - np.dot(self.w, con[1]), 0)\n if self.verbose > 5:\n print(\"slack old constraint: %f\" % slack_tmp)\n # if slack of new constraint is smaller or not\n # significantly larger, don't add constraint.\n # if smaller, complain about approximate inference.\n if slack - slack_tmp < -1e-5:\n if self.verbose > 0:\n print(\"bad inference: %f\" % (slack_tmp - slack))\n if self.break_on_bad:\n raise ValueError(\"bad inference: %f\" % (slack_tmp -\n slack))\n return True\n\n return False\n\n def fit(self, X, Y, constraints=None, warm_start=None, initialize=True):\n \"\"\"Learn parameters using cutting plane method.\n\n Parameters\n ----------\n X : iterable\n Traing instances. Contains the structured input objects.\n No requirement on the particular form of entries of X is made.\n\n Y : iterable\n Training labels. Contains the strctured labels for inputs in X.\n Needs to have the same length as X.\n\n contraints : iterable\n Known constraints for warm-starts. List of same length as X.\n Each entry is itself a list of constraints for a given instance x .\n Each constraint is of the form [y_hat, delta_joint_feature, loss], where\n y_hat is a labeling, ``delta_joint_feature = joint_feature(x, y) - joint_feature(x, y_hat)``\n and loss is the loss for predicting y_hat instead of the true label\n y.\n\n initialize : boolean, default=True\n Whether to initialize the model for the data.\n Leave this true except if you really know what you are doing.\n \"\"\"\n if self.verbose:\n print(\"Training n-slack dual structural SVM\")\n cvxopt.solvers.options['show_progress'] = self.verbose > 3\n if initialize:\n self.model.initialize(X, Y)\n self.w = np.zeros(self.model.size_joint_feature)\n n_samples = len(X)\n stopping_criterion = False\n if constraints is None:\n # fresh start\n constraints = [[] for i in range(n_samples)]\n self.last_active = [[] for i in range(n_samples)]\n self.objective_curve_ = []\n self.primal_objective_curve_ = []\n self.timestamps_ = [time()]\n else:\n # warm start\n objective = self._solve_n_slack_qp(constraints, n_samples)\n try:\n # catch ctrl+c to stop training\n # we have to update at least once after going through the dataset\n for iteration in range(self.max_iter):\n # main loop\n self.timestamps_.append(time() - self.timestamps_[0])\n if self.verbose > 0:\n print(\"iteration %d\" % iteration)\n if self.verbose > 2:\n print(self)\n new_constraints = 0\n # generate slices through dataset from batch_size\n if self.batch_size < 1 and not self.batch_size == -1:\n raise ValueError(\"batch_size should be integer >= 1 or -1,\"\n \"got %s.\" % str(self.batch_size))\n batch_size = (self.batch_size if self.batch_size != -1 else\n len(X))\n n_batches = int(np.ceil(float(len(X)) / batch_size))\n slices = gen_even_slices(n_samples, n_batches)\n indices = np.arange(n_samples)\n slack_sum = 0\n for batch in slices:\n new_constraints_batch = 0\n verbose = max(0, self.verbose - 3)\n X_b = X[batch]\n Y_b = Y[batch]\n indices_b = indices[batch]\n candidate_constraints = Parallel(\n n_jobs=self.n_jobs, verbose=verbose)(\n delayed(find_constraint)(self.model, x, y, self.w)\n for x, y in zip(X_b, Y_b))\n\n # for each batch, gather new constraints\n for i, x, y, constraint in zip(indices_b, X_b, Y_b,\n candidate_constraints):\n # loop over samples in batch\n y_hat, delta_joint_feature, slack, loss = constraint\n slack_sum += slack\n\n if self.verbose > 3:\n print(\"current slack: %f\" % slack)\n\n if not loss > 0:\n # can have y != y_hat but loss = 0 in latent svm.\n # we need this here as djoint_feature is then != 0\n continue\n\n if self._check_bad_constraint(y_hat, slack,\n constraints[i]):\n continue\n\n constraints[i].append([y_hat, delta_joint_feature, loss])\n new_constraints_batch += 1\n\n # after processing the slice, solve the qp\n if new_constraints_batch:\n objective = self._solve_n_slack_qp(constraints,\n n_samples)\n new_constraints += new_constraints_batch\n\n self.objective_curve_.append(objective)\n self._compute_training_loss(X, Y, iteration)\n\n primal_objective = (self.C\n * slack_sum\n + np.sum(self.w ** 2) / 2)\n self.primal_objective_curve_.append(primal_objective)\n\n if self.verbose > 0:\n print(\"new constraints: %d, \"\n \"cutting plane objective: %f primal objective: %f\" %\n (new_constraints, objective, primal_objective))\n\n if new_constraints == 0:\n if self.verbose:\n print(\"no additional constraints\")\n stopping_criterion = True\n\n if (iteration > 1 and self.objective_curve_[-1]\n - self.objective_curve_[-2] < self.tol):\n if self.verbose:\n print(\"objective converged.\")\n stopping_criterion = True\n\n if stopping_criterion:\n if (self.switch_to is not None and\n self.model.inference_method != self.switch_to):\n if self.verbose:\n print(\"Switching to %s inference\" %\n str(self.switch_to))\n self.model.inference_method_ = \\\n self.model.inference_method\n self.model.inference_method = self.switch_to\n stopping_criterion = False\n continue\n else:\n break\n\n if self.verbose > 5:\n print(self.w)\n\n if self.logger is not None:\n self.logger(self, iteration)\n except KeyboardInterrupt:\n pass\n\n self.constraints_ = constraints\n if self.verbose and self.n_jobs == 1:\n print(\"calls to inference: %d\" % self.model.inference_calls)\n\n if verbose:\n print(\"Computing final objective.\")\n self.timestamps_.append(time() - self.timestamps_[0])\n self.primal_objective_curve_.append(self._objective(X, Y))\n self.objective_curve_.append(objective)\n if self.logger is not None:\n self.logger(self, 'final')\n return self\n\n def prune_constraints(self, constraints, a):\n # append list for new constraint\n # self.alpha is a list which has\n # an entry per sample. each sample has an int for each constraint,\n # saying when was it last used\n if self.inactive_window == 0:\n return\n k = 0\n for i, sample in enumerate(constraints):\n # if there are no constraints for this sample, do nothing:\n if not len(sample):\n continue\n # add self.last_active for any new constraint\n n_old_constraints_sample = len(self.last_active[i])\n if n_old_constraints_sample < len(sample):\n self.last_active[i] = np.hstack([self.last_active[i], [0]])\n # if inactive, count up\n inactive_this = (a[k:k + len(sample)] < self.inactive_threshold\n * self.C)\n self.last_active[i][inactive_this] += 1\n k += len(sample)\n assert(len(sample) == len(self.last_active[i]))\n\n # remove unused constraints:\n to_remove = self.last_active[i] > self.inactive_window\n self.last_active[i] = self.last_active[i][~to_remove]\n for j in np.where(to_remove)[0][::-1]:\n del sample[j]\n assert(len(sample) == len(self.last_active[i]))\n"
] | [
[
"numpy.vstack",
"numpy.ones",
"numpy.sum",
"numpy.eye",
"numpy.zeros",
"sklearn.utils.gen_even_slices",
"sklearn.externals.joblib.delayed",
"numpy.ravel",
"numpy.arange",
"numpy.hstack",
"numpy.where",
"sklearn.externals.joblib.Parallel",
"numpy.array",
"numpy.dot",
"numpy.identity"
]
] |
ANazaret/scVI | [
"94a4a31b48b468da63417ef191db35b8bc98fbc6"
] | [
"tests/dataset/test_dataset.py"
] | [
"from unittest import TestCase\n\nimport numpy as np\nimport copy\n\nfrom scvi.dataset import CortexDataset, GeneExpressionDataset\nfrom scvi.dataset.dataset import remap_categories, CellMeasurement\n\n\nclass TestGeneExpressionDataset(TestCase):\n def test_populate_from_data(self):\n data = np.ones((25, 10)) * 100\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data)\n\n self.assertEqual(dataset.nb_genes, 10)\n self.assertEqual(dataset.nb_cells, 25)\n # default batch_indices and labels\n self.assertListEqual([[0] for i in range(25)], dataset.batch_indices.tolist())\n self.assertListEqual([[0] for i in range(25)], dataset.labels.tolist())\n\n def test_populate_from_data_with_measurements(self):\n data = np.ones((25, 10)) * 100\n paired = np.ones((25, 4)) * np.arange(0, 4)\n pair_names = [\"gabou\", \"achille\", \"pedro\", \"oclivio\"]\n y = CellMeasurement(\n name=\"dev\", data=paired, columns_attr_name=\"dev_names\", columns=pair_names\n )\n dataset = GeneExpressionDataset()\n\n dataset.populate_from_data(data, Ys=[y])\n\n self.assertEqual(dataset.nb_genes, 10)\n self.assertEqual(dataset.nb_cells, 25)\n\n self.assertTrue(hasattr(dataset, \"dev\"))\n self.assertTrue(hasattr(dataset, \"dev_names\"))\n\n self.assertListEqual(dataset.dev_names.tolist(), pair_names)\n self.assertListEqual(dataset.dev[0].tolist(), [0, 1, 2, 3])\n\n ad = dataset.to_anndata()\n self.assertTrue(\"dev\" in ad.obsm)\n\n def test_populate_from_per_batch_list(self):\n data = [\n np.random.randint(1, 5, size=(7, 10)),\n np.random.randint(1, 5, size=(5, 10)),\n np.random.randint(1, 5, size=(3, 10)),\n ]\n dataset = GeneExpressionDataset()\n dataset.populate_from_per_batch_list(data)\n self.assertEqual(dataset.nb_cells, 15)\n self.assertEqual(dataset.nb_genes, 10)\n true_batch_indices = np.concatenate(\n [\n np.zeros((7, 1), dtype=int),\n np.ones((5, 1), dtype=int),\n 2 * np.ones((3, 1), dtype=int),\n ]\n )\n self.assertListEqual(\n true_batch_indices.tolist(), dataset.batch_indices.tolist()\n )\n\n def test_populate_from_per_label_list(self):\n data = [\n np.random.randint(1, 5, size=(7, 10)),\n np.random.randint(1, 5, size=(5, 10)),\n np.random.randint(1, 5, size=(3, 10)),\n ]\n dataset = GeneExpressionDataset()\n dataset.populate_from_per_label_list(data)\n self.assertEqual(dataset.nb_cells, 15)\n self.assertEqual(dataset.nb_genes, 10)\n true_labels = np.concatenate(\n [\n np.zeros((7, 1), dtype=int),\n np.ones((5, 1), dtype=int),\n 2 * np.ones((3, 1), dtype=int),\n ]\n )\n self.assertListEqual(dataset.labels.tolist(), true_labels.tolist())\n\n def test_populate_from_datasets_dummy_data(self):\n data1 = np.random.randint(1, 5, size=(5, 10))\n gene_names1 = np.array([\"gene_%d\" % i for i in range(10)])\n dataset1 = GeneExpressionDataset()\n dataset1.populate_from_data(data1, gene_names=gene_names1)\n data2 = np.random.randint(1, 5, size=(7, 3))\n gene_names2 = np.array([\"gene_%d\" % i for i in range(3)])\n dataset2 = GeneExpressionDataset()\n dataset2.populate_from_data(data2, gene_names=gene_names2)\n data3 = np.random.randint(1, 5, size=(2, 5))\n gene_names3 = np.array([\"gene_%d\" % i for i in range(5)])\n dataset3 = GeneExpressionDataset()\n dataset3.populate_from_data(data3, gene_names=gene_names3)\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_datasets([dataset1, dataset2, dataset3])\n self.assertEqual(14, dataset.nb_cells)\n self.assertEqual(3, dataset.nb_genes)\n self.assertListEqual(\n [\"gene_0\", \"gene_1\", \"gene_2\"], dataset.gene_names.tolist()\n )\n\n # test for labels sharing\n dataset2.labels = [0, 0, 0, 1, 1, 1, 1]\n dataset2.initialize_mapped_attribute(\"labels\", \"cell_types\", [\"0\", \"1\"])\n dataset3.labels = [0, 1]\n dataset3.initialize_mapped_attribute(\"labels\", \"cell_types\", [\"0\", \"2\"])\n dataset = GeneExpressionDataset()\n dataset.populate_from_datasets([dataset2, dataset3], shared_labels=True)\n self.assertListEqual(\n np.squeeze(dataset.labels).tolist(), [0, 0, 0, 1, 1, 1, 1, 0, 2]\n )\n self.assertListEqual(dataset.cell_types, [\"0\", \"1\", \"2\"])\n\n dataset_unshared = GeneExpressionDataset()\n dataset_unshared.populate_from_datasets(\n [dataset2, dataset3], shared_labels=False\n )\n self.assertListEqual(\n np.squeeze(dataset_unshared.labels).tolist(), [0, 0, 0, 1, 1, 1, 1, 2, 3]\n )\n self.assertListEqual(dataset_unshared.cell_types, [\"0\", \"1\", \"0\", \"2\"])\n\n # test for batch_indices offsetting\n dataset2.batch_indices = [0, 0, 0, 1, 1, 1, 1]\n dataset2.initialize_mapped_attribute(\n \"batch_indices\", \"experiment\", [\"fish_2\", \"scrna_2\"]\n )\n dataset3.batch_indices = [0, 1]\n dataset3.initialize_mapped_attribute(\n \"batch_indices\", \"experiment\", [\"fish_3\", \"scrna_3\"]\n )\n dataset = GeneExpressionDataset()\n dataset.populate_from_datasets([dataset2, dataset3])\n self.assertListEqual(\n np.squeeze(dataset.batch_indices).tolist(), [0, 0, 0, 1, 1, 1, 1, 2, 3]\n )\n self.assertListEqual(\n getattr(dataset, \"experiment\"), [\"fish_2\", \"scrna_2\", \"fish_3\", \"scrna_3\"]\n )\n\n def test_populate_from_datasets_gene_attributes_merging(self):\n data = np.random.randint(1, 5, size=(5, 10))\n gene_names = np.array([\"gene_%d\" % i for i in range(10)])\n gene_attr1 = np.array([[\"1\"] for _ in range(10)])\n gene_attr2 = np.array([[\"2\"] for _ in range(10)])\n dataset1 = GeneExpressionDataset()\n dataset2 = GeneExpressionDataset()\n\n dataset1.populate_from_data(\n data, gene_names=gene_names, gene_attributes_dict={\"test\": gene_attr1}\n )\n dataset2.populate_from_data(\n data, gene_names=gene_names, gene_attributes_dict={\"test\": gene_attr2}\n )\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_datasets([dataset1, dataset2])\n\n # Should keep the gene attribute of the first dataset\n self.assertEqual(dataset.test[0, 0], \"1\")\n\n def test_populate_from_datasets_cell_attributes_merging(self):\n data = np.random.randint(1, 5, size=(5, 10))\n gene_names = np.array([\"gene_%d\" % i for i in range(10)])\n cell_attr1 = np.array([[\"1\"] for _ in range(5)])\n cell_attr2 = np.array([[\"2\"] for _ in range(5)])\n dataset1 = GeneExpressionDataset()\n dataset2 = GeneExpressionDataset()\n\n dataset1.populate_from_data(\n data, gene_names=gene_names, cell_attributes_dict={\"test\": cell_attr1}\n )\n dataset2.populate_from_data(\n data, gene_names=gene_names, cell_attributes_dict={\"test\": cell_attr2}\n )\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_datasets([dataset1, dataset2])\n self.assertTupleEqual(dataset.test.shape, (10, 1))\n self.assertListEqual(np.squeeze(dataset.test).tolist(), [\"1\"] * 5 + [\"2\"] * 5)\n\n def test_populate_from_datasets_with_measurments(self):\n data = np.random.randint(1, 5, size=(5, 10))\n gene_names = np.array([\"gene_%d\" % i for i in range(10)])\n\n paired1 = np.ones((5, 5)) * np.arange(0, 5)\n pair_names1 = [\"gabou\", \"achille\", \"pedro\", \"oclivio\", \"gayoso\"]\n y1 = CellMeasurement(\n name=\"dev\", data=paired1, columns_attr_name=\"dev_names\", columns=pair_names1\n )\n paired2 = np.ones((5, 4)) * np.arange(0, 4)\n pair_names2 = [\"gabou\", \"oclivio\", \"achille\", \"pedro\"]\n y2 = CellMeasurement(\n name=\"dev\", data=paired2, columns_attr_name=\"dev_names\", columns=pair_names2\n )\n\n dataset1 = GeneExpressionDataset()\n dataset2 = GeneExpressionDataset()\n\n dataset1.populate_from_data(data, Ys=[y1], gene_names=gene_names)\n dataset2.populate_from_data(data, Ys=[y2], gene_names=gene_names)\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_datasets(\n [copy.deepcopy(dataset1), copy.deepcopy(dataset2)]\n )\n\n self.assertTrue(hasattr(dataset, \"dev\"))\n self.assertTrue(hasattr(dataset, \"dev_names\"))\n\n self.assertListEqual(\n dataset.dev_names.tolist(), [\"achille\", \"gabou\", \"oclivio\", \"pedro\"]\n )\n self.assertListEqual(dataset.dev[0].tolist(), [1, 0, 3, 2])\n self.assertListEqual(dataset.dev[5].tolist(), [2, 0, 1, 3])\n\n # Take union of dev columns, 0s fill remainder\n dataset = GeneExpressionDataset()\n dataset.populate_from_datasets(\n [copy.deepcopy(dataset1), copy.deepcopy(dataset2)],\n cell_measurement_intersection={\"dev\": False},\n )\n self.assertListEqual(\n dataset.dev_names.tolist(),\n [\"achille\", \"gabou\", \"gayoso\", \"oclivio\", \"pedro\"],\n )\n mask = dataset.get_batch_mask_cell_measurement(\"dev\")\n self.assertEqual(mask[1][2].astype(int), 0)\n\n def test_populate_from_datasets_cortex(self):\n cortex_dataset_1 = CortexDataset(save_path=\"tests/data\")\n cortex_dataset_1.subsample_genes(subset_genes=np.arange(0, 3), mode=\"variance\")\n cortex_dataset_1.filter_cell_types([\"microglia\", \"oligodendrocytes\"])\n cortex_dataset_2 = CortexDataset(save_path=\"tests/data\")\n cortex_dataset_2.subsample_genes(subset_genes=np.arange(1, 4), mode=\"variance\")\n cortex_dataset_2.filter_cell_types(\n [\"endothelial-mural\", \"interneurons\", \"microglia\", \"oligodendrocytes\"]\n )\n cortex_dataset_2.filter_cell_types([2, 0])\n dataset = GeneExpressionDataset()\n dataset.populate_from_datasets([cortex_dataset_1, cortex_dataset_2])\n self.assertEqual(2, dataset.nb_genes)\n\n def test_labels(self):\n data = np.ones((25, 10)) * 100\n labels = np.array(range(25))\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, labels=labels)\n self.assertTupleEqual((25, 1), dataset.labels.shape)\n self.assertEqual(dataset.labels[5, 0], 5)\n\n labels = np.ones(25) * 5\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, labels=labels)\n self.assertTupleEqual(dataset.labels.shape, (25, 1))\n self.assertEqual(dataset.labels[5, 0], 0)\n\n def test_remap_categorical_attributes(self):\n data = np.random.randint(1, 5, size=(7, 11))\n labels = [1, 1, 1, 1, 1, 2, 2]\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, labels=labels)\n\n labels_true = [0, 0, 0, 0, 0, 1, 1]\n labels_true = [[i] for i in labels_true]\n self.assertListEqual(labels_true, dataset.labels.tolist())\n\n def test_compute_library_size_batch(self):\n data = np.exp(10) / 10 * np.ones((7, 10), dtype=int)\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data)\n\n local_means_true = [[10.0] for _ in range(7)]\n local_vars_true = [[0.0] for _ in range(7)]\n self.assertEqual(local_means_true, dataset.local_means.tolist())\n self.assertEqual(local_vars_true, dataset.local_vars.tolist())\n\n def test_subsample_genes(self):\n data = np.ones((25, 100)) * 100\n variable_data = data\n variable_data[0, :] = 2\n variable_data *= np.arange(0, 100)\n\n gene_names = np.array([\"gene_%d\" % i for i in range(100)])\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, gene_names=gene_names)\n dataset.subsample_genes(new_ratio_genes=0.4, mode=\"variance\")\n self.assertTupleEqual(dataset.gene_names.shape, (40,))\n dataset.subsample_genes(new_n_genes=25, mode=\"variance\")\n self.assertTupleEqual(dataset.gene_names.shape, (25,))\n # The most variable genes should be in first position\n self.assertEqual(dataset.gene_names[0], \"gene_99\")\n dataset.subsample_genes(subset_genes=[1, 6, 7])\n self.assertEqual(dataset.gene_names[0], \"gene_98\")\n\n def test_filter_genes(self):\n data = np.random.randint(1, 5, size=(5, 10))\n gene_names = np.array([\"gene_%d\" % i for i in range(10)])\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, gene_names=gene_names)\n gene_names_true = [\"gene_1\", \"gene_3\"]\n dataset.filter_genes_by_attribute(gene_names_true)\n self.assertListEqual(gene_names_true, dataset.gene_names.tolist())\n\n def test_reorder_genes(self):\n data = np.ones((25, 100)) * 100\n\n gene_names = np.array([\"gene_%d\" % i for i in range(100)])\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, gene_names=gene_names)\n dataset.reorder_genes([\"gene_47\", \"gene_2\", \"gene_3\", \"gene_12\"])\n # New order should be 47, 2, 3, 12, 0, 1, ...\n self.assertListEqual(\n list(dataset.gene_names[0:6]),\n [\"gene_47\", \"gene_2\", \"gene_3\", \"gene_12\", \"gene_0\", \"gene_1\"],\n )\n\n self.assertRaises(KeyError, dataset.reorder_genes, [\"gene_101\"])\n\n def test_genes_to_idx(self):\n data = np.random.randint(1, 5, size=(5, 10))\n gene_names = np.array([\"gene_%d\" % i for i in range(10)])\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, gene_names=gene_names)\n indices = dataset.genes_to_index([\"gene_%d\" % i for i in range(10)])\n self.assertListEqual([i for i in range(10)], indices.tolist())\n\n def test_subsample_cells(self):\n data = np.arange(1, 6)[:, None] * np.ones(7)[None, :]\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data)\n # default\n dataset.subsample_cells()\n self.assertEqual(5, dataset.nb_cells)\n # when size is a float\n dataset.subsample_cells(size=0.8)\n data_true = np.arange(5, 1, -1)[:, None] * np.ones(7)[None, :]\n self.assertListEqual(data_true.tolist(), dataset.X.tolist())\n # when size is an int\n dataset.subsample_cells(size=2)\n self.assertEqual(2, dataset.nb_cells)\n\n def test_filter_cells(self):\n data = np.ones((25, 10)) * 100\n data[4:6, :] = 0\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data)\n self.assertEqual(25, dataset.nb_cells)\n dataset.filter_cells_by_count()\n self.assertEqual(23, dataset.nb_cells)\n\n def test_filter_cell_types(self):\n data = np.random.randint(1, 5, size=(5, 10))\n labels = [0, 0, 1, 1, 1]\n cell_types = [\"0\", \"1\"]\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, labels=labels, cell_types=cell_types)\n dataset.filter_cell_types([\"0\"])\n self.assertListEqual(data[:2].tolist(), dataset.X.tolist())\n\n def test_merge_cell_types(self):\n data = np.random.randint(1, 5, size=(8, 20))\n labels = [0, 0, 1, 2, 2, 1, 0, 1]\n cell_types = [\"0\", \"1\", \"2\"]\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, labels=labels, cell_types=cell_types)\n dataset.merge_cell_types([\"0\", \"1\"], new_cell_type_name=\"0 and 1\")\n self.assertListEqual(\n [[3], [3], [3], [2], [2], [3], [3], [3]], dataset.labels.tolist()\n )\n dataset.remap_categorical_attributes()\n self.assertListEqual(\n [[1], [1], [1], [0], [0], [1], [1], [1]], dataset.labels.tolist()\n )\n self.assertListEqual([\"2\", \"0 and 1\"], dataset.cell_types.tolist())\n\n def test_map_cell_types(self):\n data = np.random.randint(1, 5, size=(7, 10))\n labels = [0, 0, 4, 4, 2, 3, 5]\n cell_types = [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\"]\n\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, labels=labels, cell_types=cell_types)\n dataset.map_cell_types({(\"0\", \"2\"): \"6\", (\"3\", \"4\"): \"7\"})\n dataset.remap_categorical_attributes()\n self.assertListEqual(dataset.cell_types.tolist(), [\"5\", \"6\", \"7\"])\n self.assertListEqual(np.squeeze(dataset.labels).tolist(), [1, 1, 2, 2, 1, 2, 0])\n\n\nclass TestCollate(TestCase):\n def test_collate_normal(self):\n data = np.ones((25, 2)) * np.arange(0, 25).reshape((-1, 1))\n batch_indices = np.arange(0, 25).reshape((-1, 1))\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(data, batch_indices=batch_indices)\n\n collate_fn = dataset.collate_fn_builder()\n x, mean, var, batch, labels = collate_fn([1, 2])\n self.assertListEqual(x.tolist(), [[1.0, 1.0], [2.0, 2.0]])\n self.assertListEqual(batch.tolist(), [[1], [2]])\n\n def test_collate_add(self):\n data = np.ones((25, 2)) * np.arange(0, 25).reshape((-1, 1))\n batch_indices = np.arange(0, 25).reshape((-1, 1))\n x_coords = np.arange(0, 25).reshape((-1, 1))\n proteins = (\n np.ones((25, 3)) + np.arange(0, 25).reshape((-1, 1)) + np.arange(0, 3)\n )\n proteins_name = [\"A\", \"B\", \"C\"]\n dataset = GeneExpressionDataset()\n dataset.populate_from_data(\n data,\n batch_indices=batch_indices,\n cell_attributes_dict={\"x_coords\": x_coords},\n Ys=[\n CellMeasurement(\n name=\"proteins\",\n data=proteins,\n columns_attr_name=\"protein_names\",\n columns=proteins_name,\n )\n ],\n )\n\n collate_fn = dataset.collate_fn_builder(\n add_attributes_and_types={\"x_coords\": np.float32, \"proteins\": np.float32}\n )\n x, mean, var, batch, labels, x_coords_tensor, proteins_tensor = collate_fn(\n [1, 2]\n )\n self.assertListEqual(x_coords_tensor.tolist(), [[1.0], [2.0]])\n self.assertListEqual(\n proteins_tensor.tolist(), [[2.0, 3.0, 4.0], [3.0, 4.0, 5.0]]\n )\n\n\nclass TestRemapCategories(TestCase):\n def test_remap_categories(self):\n labels = [0, 0, 0, 2, 2, 3]\n labels, n_labels = remap_categories(labels)\n labels_true = [0, 0, 0, 1, 1, 2]\n self.assertListEqual(labels_true, labels.tolist())\n self.assertEqual(3, n_labels)\n\n # with absent categories and mappings\n labels = [2, 2, 3]\n mappings_dict = {\"cell_types\": [\"0\", \"1\", \"2\", \"3\"]}\n labels, n_labels, mappings = remap_categories(\n labels, mappings_dict=mappings_dict\n )\n labels_true = [0, 0, 1]\n self.assertListEqual(labels_true, labels.tolist())\n self.assertEqual(2, n_labels)\n self.assertListEqual([\"2\", \"3\"], mappings[\"cell_types\"].tolist())\n"
] | [
[
"numpy.ones",
"numpy.zeros",
"numpy.squeeze",
"numpy.exp",
"numpy.arange",
"numpy.random.randint"
]
] |
zhanglei1172/bbobenchmark | [
"841bffdddc1320ac2676e378d20f8b176a7e6cf7"
] | [
"examples/transfer_bo.py"
] | [
"import numpy as np\n# import matplotlib.pyplot as plt\nfrom xbbo.configspace.space import DenseConfiguration, DenseConfigurationSpace\nfrom ConfigSpace.hyperparameters import UniformFloatHyperparameter\nfrom ConfigSpace.conditions import LessThanCondition\n\n# from xbbo.search_algorithm.transfer_tst_optimizer import SMBO\n# from xbbo.search_algorithm.transfer_taf_optimizer import SMBO\n# from xbbo.search_algorithm.transfer_rgpe_mean_optimizer import SMBO\n# from xbbo.search_algorithm.transfer_taf_rgpe_optimizer import SMBO\n# from xbbo.search_algorithm.transfer_RMoGP_optimizer import SMBO\nfrom xbbo.search_algorithm.transfer_bo_optimizer import SMBO\n\nfrom xbbo.search_space.offline_hp import Model\nfrom xbbo.utils.constants import MAXINT\nfrom xbbo.surrogate.transfer.base_surrogate import BaseModel\n\ndef rosenbrock_2d(x):\n \"\"\" The 2 dimensional Rosenbrock function as a toy model\n The Rosenbrock function is well know in the optimization community and\n often serves as a toy problem. It can be defined for arbitrary\n dimensions. The minimium is always at x_i = 1 with a function value of\n zero. All input parameters are continuous. The search domain for\n all x's is the interval [-5, 10].\n \"\"\"\n\n x1 = x[\"x0\"]\n # x2 = x[\"x1\"]\n x2 = x.get('x1', x1)\n\n val = 100. * (x2 - x1 ** 2.) ** 2. + (1 - x1) ** 2.\n return val\n\ndef branin(config):\n x1, x2 = config['x1'], config['x2']\n y = (x2 - 5.1 / (4 * np.pi ** 2) * x1 ** 2 + 5 / np.pi * x1 - 6) ** 2 \\\n + 10 * (1 - 1 / (8 * np.pi)) * np.cos(x1) + 10\n return y\n\ndef build_space(rng):\n cs = DenseConfigurationSpace(seed=rng.randint(10000))\n x0 = UniformFloatHyperparameter(\"x0\", -5, 10, default_value=-3)\n x1 = UniformFloatHyperparameter(\"x1\", -5, 10, default_value=-4)\n cs.add_hyperparameters([x0, x1])\n con = LessThanCondition(x1, x0, 1.)\n cs.add_condition(con)\n return cs\n\ndef build_branin_space(rng):\n cs = DenseConfigurationSpace(seed=rng.randint(10000))\n x1 = UniformFloatHyperparameter(\"x1\", -5, 10, default_value=0)\n x2 = UniformFloatHyperparameter(\"x2\", 0, 15, default_value=0)\n cs.add_hyperparameters([x1, x2])\n return cs\n\nif __name__ == \"__main__\":\n MAX_CALL = 30\n rng = np.random.RandomState(42)\n\n test_model = Model(None, rng.randint(MAXINT), test_task='a6a', )\n\n cs = DenseConfigurationSpace(seed=rng.randint(MAXINT))\n confs = test_model.get_api_config()\n for conf in confs:\n cs.add_hyperparameter(UniformFloatHyperparameter(conf, confs[conf]['range'][0], confs[conf]['range'][1]))\n blackbox_func = test_model.evaluate\n base_models = []\n for i in range(len(test_model.old_D_x)):\n base_models.append(BaseModel(cs, rng=rng,do_optimize=False))\n base_models[-1].train(test_model.old_D_x[i], test_model.old_D_y[i])\n\n # use transfer\n # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_func='ei', weight_srategy='kernel', acq_opt='rs', base_models=base_models) # vanila bo\n # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='tst', acq_func='ei', weight_srategy='kernel', acq_opt='rs', base_models=base_models) # TST-R\n # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_func='taf', weight_srategy='kernel', acq_opt='rs', base_models=base_models) # TAF\n # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='tst', acq_func='ei', weight_srategy='rw', acq_opt='rs', base_models=base_models) # RGPE(mean)\n # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_func='taf', weight_srategy='rw', acq_opt='rs', base_models=base_models) # TAF(rw)\n hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_func='mogp', weight_srategy='rw', acq_opt='rs', base_models=base_models) # RMoGP\n # not use transfer\n # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_opt='rs_ls', base_models=[]]) \n # Example call of the black-box function\n def_value = blackbox_func(cs.get_default_configuration())\n print(\"Default Value: %.2f\" % def_value)\n # ---- Begin BO-loop ----\n for i in range(MAX_CALL):\n # suggest\n trial_list = hpopt.suggest()\n # evaluate \n value = blackbox_func(trial_list[0].config_dict)\n # observe\n trial_list[0].add_observe_value(observe_value=value)\n hpopt.observe(trial_list=trial_list)\n \n print(value)\n \n # plt.plot(hpopt.trials.get_history()[0])\n # plt.savefig('./out/rosenbrock_bo_gp.png')\n # plt.show()\n print('find best value:{}'.format(hpopt.trials.get_best()[0]))\n\n"
] | [
[
"numpy.random.RandomState",
"numpy.cos"
]
] |
Femi-Tofade/Plagiarism_detector | [
"026164ec11415bc566f4d817dc79c9cecf06a0c0"
] | [
"source_pytorch/predict.py"
] | [
"# import libraries\r\nimport os\r\nimport numpy as np\r\nimport torch\r\nfrom six import BytesIO\r\n\r\n# import model from model.py, by name\r\nfrom model import BinaryClassifier\r\n\r\n# default content type is numpy array\r\nNP_CONTENT_TYPE = 'application/x-npy'\r\n\r\n\r\n# Provided model load function\r\ndef model_fn(model_dir):\r\n \"\"\"Load the PyTorch model from the `model_dir` directory.\"\"\"\r\n print(\"Loading model.\")\r\n\r\n # First, load the parameters used to create the model.\r\n model_info = {}\r\n model_info_path = os.path.join(model_dir, 'model_info.pth')\r\n with open(model_info_path, 'rb') as f:\r\n model_info = torch.load(f)\r\n\r\n print(\"model_info: {}\".format(model_info))\r\n\r\n # Determine the device and construct the model.\r\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\r\n model = BinaryClassifier(model_info['input_features'], model_info['hidden_dim'], model_info['output_dim'])\r\n\r\n # Load the store model parameters.\r\n model_path = os.path.join(model_dir, 'model.pth')\r\n with open(model_path, 'rb') as f:\r\n model.load_state_dict(torch.load(f))\r\n\r\n # Prep for testing\r\n model.to(device).eval()\r\n\r\n print(\"Done loading model.\")\r\n return model\r\n\r\n\r\n# Provided input data loading\r\ndef input_fn(serialized_input_data, content_type):\r\n print('Deserializing the input data.')\r\n if content_type == NP_CONTENT_TYPE:\r\n stream = BytesIO(serialized_input_data)\r\n return np.load(stream)\r\n raise Exception('Requested unsupported ContentType in content_type: ' + content_type)\r\n\r\n# Provided output data handling\r\ndef output_fn(prediction_output, accept):\r\n print('Serializing the generated output.')\r\n if accept == NP_CONTENT_TYPE:\r\n stream = BytesIO()\r\n np.save(stream, prediction_output)\r\n return stream.getvalue(), accept\r\n raise Exception('Requested unsupported ContentType in Accept: ' + accept)\r\n\r\n\r\n# Provided predict function\r\ndef predict_fn(input_data, model):\r\n print('Predicting class labels for the input data...')\r\n\r\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\r\n \r\n # Process input_data so that it is ready to be sent to our model.\r\n data = torch.from_numpy(input_data.astype('float32'))\r\n data = data.to(device)\r\n\r\n # Put the model into evaluation mode\r\n model.eval()\r\n\r\n # Compute the result of applying the model to the input data\r\n # The variable `out_label` should be a rounded value, either 1 or 0\r\n out = model(data)\r\n out_np = out.cpu().detach().numpy()\r\n out_label = out_np.round()\r\n\r\n return out_label"
] | [
[
"numpy.load",
"numpy.save",
"torch.cuda.is_available",
"torch.load"
]
] |
rryoung98/pennylane | [
"0c1c805fd5dfce465a8955ee3faf81037023a23e"
] | [
"tests/templates/test_layers/test_particle_conserving_u2.py"
] | [
"# Copyright 2018-2021 Xanadu Quantum Technologies Inc.\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\"\"\"\nUnit tests for the ParticleConservingU2 template.\n\"\"\"\nimport pytest\nimport numpy as np\nimport pennylane as qml\nfrom pennylane import numpy as pnp\n\n\nclass TestDecomposition:\n \"\"\"Tests that the template defines the correct decomposition.\"\"\"\n\n @pytest.mark.parametrize(\n \"layers, qubits, init_state\",\n [\n (2, 4, np.array([1, 1, 0, 0])),\n (1, 6, np.array([1, 1, 0, 0, 0, 0])),\n (1, 5, np.array([1, 1, 0, 0, 0])),\n ],\n )\n def test_operations(self, layers, qubits, init_state):\n \"\"\"Test the correctness of the ParticleConservingU2 template including the gate count\n and order, the wires each operation acts on and the correct use of parameters\n in the circuit.\"\"\"\n weights = np.random.normal(0, 2 * np.pi, (layers, 2 * qubits - 1))\n\n n_gates = 1 + (qubits + (qubits - 1) * 3) * layers\n\n exp_gates = (\n [qml.RZ] * qubits + ([qml.CNOT] + [qml.CRX] + [qml.CNOT]) * (qubits - 1)\n ) * layers\n\n op = qml.templates.ParticleConservingU2(weights, wires=range(qubits), init_state=init_state)\n queue = op.expand().operations\n\n # number of gates\n assert len(queue) == n_gates\n\n # initialization\n assert isinstance(queue[0], qml.BasisState)\n\n # order of gates\n for op1, op2 in zip(queue[1:], exp_gates):\n assert isinstance(op1, op2)\n\n # gate parameter\n params = np.array(\n [queue[i].parameters for i in range(1, n_gates) if queue[i].parameters != []]\n )\n weights[:, qubits:] = weights[:, qubits:] * 2\n assert np.allclose(params.flatten(), weights.flatten())\n\n # gate wires\n wires = range(qubits)\n nm_wires = [wires[l : l + 2] for l in range(0, qubits - 1, 2)]\n nm_wires += [wires[l : l + 2] for l in range(1, qubits - 1, 2)]\n\n exp_wires = []\n for _ in range(layers):\n for i in range(qubits):\n exp_wires.append([wires[i]])\n for j in nm_wires:\n exp_wires.append(list(j))\n exp_wires.append(list(j[::-1]))\n exp_wires.append(list(j))\n\n res_wires = [queue[i].wires.tolist() for i in range(1, n_gates)]\n\n assert res_wires == exp_wires\n\n @pytest.mark.parametrize(\n (\"init_state\", \"exp_state\"),\n [\n (np.array([0, 0]), np.array([1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j])),\n (\n np.array([0, 1]),\n np.array([0.0 + 0.0j, 0.862093 + 0.0j, 0.0 - 0.506749j, 0.0 + 0.0j]),\n ),\n (\n np.array([1, 0]),\n np.array([0.0 + 0.0j, 0.0 - 0.506749j, 0.862093 + 0.0j, 0.0 + 0.0j]),\n ),\n (np.array([1, 1]), np.array([0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j])),\n ],\n )\n def test_decomposition_u2ex(self, init_state, exp_state, tol):\n \"\"\"Test the decomposition of the U_{2, ex}` exchange gate by asserting the prepared\n state.\"\"\"\n\n N = 2\n wires = range(N)\n\n weight = 0.53141\n\n dev = qml.device(\"default.qubit\", wires=N)\n\n @qml.qnode(dev)\n def circuit(weight):\n qml.BasisState(init_state, wires=wires)\n qml.templates.layers.particle_conserving_u2.u2_ex_gate(weight, wires)\n return qml.expval(qml.PauliZ(0))\n\n circuit(weight)\n\n assert np.allclose(circuit.device.state, exp_state, atol=tol)\n\n def test_custom_wire_labels(self, tol):\n \"\"\"Test that template can deal with non-numeric, nonconsecutive wire labels.\"\"\"\n weights = np.random.random(size=(1, 5))\n init_state = np.array([1, 1, 0])\n\n dev = qml.device(\"default.qubit\", wires=3)\n dev2 = qml.device(\"default.qubit\", wires=[\"z\", \"a\", \"k\"])\n\n @qml.qnode(dev)\n def circuit():\n qml.templates.ParticleConservingU2(weights, wires=range(3), init_state=init_state)\n return qml.expval(qml.Identity(0))\n\n @qml.qnode(dev2)\n def circuit2():\n qml.templates.ParticleConservingU2(\n weights, wires=[\"z\", \"a\", \"k\"], init_state=init_state\n )\n return qml.expval(qml.Identity(\"z\"))\n\n circuit()\n circuit2()\n\n assert np.allclose(dev.state, dev2.state, atol=tol, rtol=0)\n\n\nclass TestInputs:\n \"\"\"Test inputs and pre-processing.\"\"\"\n\n @pytest.mark.parametrize(\n (\"weights\", \"wires\", \"msg_match\"),\n [\n (\n np.array([[-0.080, 2.629, -0.710, 5.383, 0.646, -2.872, -3.856]]),\n [0],\n \"This template requires the number of qubits to be greater than one\",\n ),\n (\n np.array([[-0.080, 2.629, -0.710, 5.383]]),\n [0, 1, 2, 3],\n \"Weights tensor must\",\n ),\n (\n np.array(\n [\n [-0.080, 2.629, -0.710, 5.383, 0.646, -2.872],\n [-0.080, 2.629, -0.710, 5.383, 0.646, -2.872],\n ]\n ),\n [0, 1, 2, 3],\n \"Weights tensor must\",\n ),\n (\n np.array([-0.080, 2.629, -0.710, 5.383, 0.646, -2.872]),\n [0, 1, 2, 3],\n \"Weights tensor must be 2-dimensional\",\n ),\n ],\n )\n def test_exceptions(self, weights, wires, msg_match):\n \"\"\"Test that ParticleConservingU2 throws an exception if the parameters have illegal\n shapes, types or values.\"\"\"\n N = len(wires)\n init_state = np.array([1, 1, 0, 0])\n\n dev = qml.device(\"default.qubit\", wires=N)\n\n @qml.qnode(dev)\n def circuit():\n qml.templates.ParticleConservingU2(\n weights=weights,\n wires=wires,\n init_state=init_state,\n )\n return qml.expval(qml.PauliZ(0))\n\n with pytest.raises(ValueError, match=msg_match):\n circuit()\n\n\nclass TestAttributes:\n \"\"\"Tests additional methods and attributes\"\"\"\n\n @pytest.mark.parametrize(\n \"n_layers, n_wires, expected_shape\",\n [\n (2, 3, (2, 5)),\n (2, 2, (2, 3)),\n (1, 3, (1, 5)),\n ],\n )\n def test_shape(self, n_layers, n_wires, expected_shape):\n \"\"\"Test that the shape method returns the correct shape of the weights tensor\"\"\"\n\n shape = qml.templates.ParticleConservingU2.shape(n_layers, n_wires)\n assert shape == expected_shape\n\n def test_shape_exception_not_enough_qubits(self):\n \"\"\"Test that the shape function warns if there are not enough qubits.\"\"\"\n\n with pytest.raises(ValueError, match=\"The number of qubits must be greater than one\"):\n qml.templates.ParticleConservingU2.shape(3, 1)\n\n\ndef circuit_template(weights):\n qml.templates.ParticleConservingU2(weights, range(2), init_state=np.array([1, 1]))\n return qml.expval(qml.PauliZ(0))\n\n\ndef circuit_decomposed(weights):\n qml.BasisState(np.array([1, 1]), wires=[0, 1])\n qml.RZ(weights[0, 0], wires=[0])\n qml.RZ(weights[0, 1], wires=[1])\n qml.CNOT(wires=[0, 1])\n qml.CRX(weights[0, 2], wires=[1, 0])\n qml.CNOT(wires=[0, 1])\n return qml.expval(qml.PauliZ(0))\n\n\nclass TestInterfaces:\n \"\"\"Tests that the template is compatible with all interfaces, including the computation\n of gradients.\"\"\"\n\n def test_list_and_tuples(self, tol):\n \"\"\"Tests common iterables as inputs.\"\"\"\n\n weights = [[0.1, -1.1, 0.2]]\n\n dev = qml.device(\"default.qubit\", wires=2)\n\n circuit = qml.QNode(circuit_template, dev)\n circuit2 = qml.QNode(circuit_decomposed, dev)\n\n res = circuit(weights)\n res2 = circuit2(weights)\n assert qml.math.allclose(res, res2, atol=tol, rtol=0)\n\n weights_tuple = [tuple(weights[0])]\n res = circuit(weights_tuple)\n res2 = circuit2(weights_tuple)\n assert qml.math.allclose(res, res2, atol=tol, rtol=0)\n\n def test_autograd(self, tol):\n \"\"\"Tests the autograd interface.\"\"\"\n\n weights = np.random.random(size=(1, 3))\n weights = pnp.array(weights, requires_grad=True)\n\n dev = qml.device(\"default.qubit\", wires=2)\n\n circuit = qml.QNode(circuit_template, dev)\n circuit2 = qml.QNode(circuit_decomposed, dev)\n\n res = circuit(weights)\n res2 = circuit2(weights)\n assert qml.math.allclose(res, res2, atol=tol, rtol=0)\n\n grad_fn = qml.grad(circuit)\n grads = grad_fn(weights)\n\n grad_fn2 = qml.grad(circuit2)\n grads2 = grad_fn2(weights)\n\n assert np.allclose(grads[0], grads2[0], atol=tol, rtol=0)\n\n def test_jax(self, tol):\n \"\"\"Tests the jax interface.\"\"\"\n\n jax = pytest.importorskip(\"jax\")\n import jax.numpy as jnp\n\n weights = jnp.array(np.random.random(size=(1, 3)))\n\n dev = qml.device(\"default.qubit\", wires=2)\n\n circuit = qml.QNode(circuit_template, dev, interface=\"jax\")\n circuit2 = qml.QNode(circuit_decomposed, dev, interface=\"jax\")\n\n res = circuit(weights)\n res2 = circuit2(weights)\n assert qml.math.allclose(res, res2, atol=tol, rtol=0)\n\n grad_fn = jax.grad(circuit)\n grads = grad_fn(weights)\n\n grad_fn2 = jax.grad(circuit2)\n grads2 = grad_fn2(weights)\n\n assert np.allclose(grads[0], grads2[0], atol=tol, rtol=0)\n\n def test_tf(self, tol):\n \"\"\"Tests the tf interface.\"\"\"\n\n tf = pytest.importorskip(\"tensorflow\")\n\n weights = tf.Variable(np.random.random(size=(1, 3)))\n\n dev = qml.device(\"default.qubit\", wires=2)\n\n circuit = qml.QNode(circuit_template, dev, interface=\"tf\")\n circuit2 = qml.QNode(circuit_decomposed, dev, interface=\"tf\")\n\n res = circuit(weights)\n res2 = circuit2(weights)\n assert qml.math.allclose(res, res2, atol=tol, rtol=0)\n\n with tf.GradientTape() as tape:\n res = circuit(weights)\n grads = tape.gradient(res, [weights])\n\n with tf.GradientTape() as tape2:\n res2 = circuit2(weights)\n grads2 = tape2.gradient(res2, [weights])\n\n assert np.allclose(grads[0], grads2[0], atol=tol, rtol=0)\n\n def test_torch(self, tol):\n \"\"\"Tests the torch interface.\"\"\"\n\n torch = pytest.importorskip(\"torch\")\n\n weights = torch.tensor(np.random.random(size=(1, 3)), requires_grad=True)\n\n dev = qml.device(\"default.qubit\", wires=2)\n\n circuit = qml.QNode(circuit_template, dev, interface=\"torch\")\n circuit2 = qml.QNode(circuit_decomposed, dev, interface=\"torch\")\n\n res = circuit(weights)\n res2 = circuit2(weights)\n assert qml.math.allclose(res, res2, atol=tol, rtol=0)\n\n res = circuit(weights)\n res.backward()\n grads = [weights.grad]\n\n res2 = circuit2(weights)\n res2.backward()\n grads2 = [weights.grad]\n\n assert np.allclose(grads[0], grads2[0], atol=tol, rtol=0)\n"
] | [
[
"numpy.random.normal",
"numpy.allclose",
"numpy.array",
"numpy.random.random"
]
] |
cce-bigdataintro-1160/spring2019 | [
"e55b24bda61bbc87ad39dfec93c68a8f2da77831"
] | [
"class5-notebook/6-pandas_creating_series.py"
] | [
"#!/usr/bin/env python3\n\nimport numpy as np\nimport pandas as pd\n\n\ndef pretty_print(name, to_print):\n print(f'{name}:')\n print(f'{to_print}\\n\\n')\n\n\norders = pd.Series(data=[300.50, 60, 123.40, 60, np.nan],\n index=['Customer 1', 'Customer 2', 'Customer 3', 'Customer 4', 'Customer 5'])\n\npretty_print(\"orders\", orders.to_string())\npretty_print(\"first row of orders\", orders.head(n=1))\npretty_print(\"orders indexes\", orders.index)\npretty_print(\"order types\", orders.dtypes)\npretty_print(\"orders shape\", orders.shape)\n\npretty_print(\"orders description with types\", orders.describe())\npretty_print(\"orders sorted values\", orders.sort_values())\npretty_print(\"orders counts of values\", orders.value_counts())\npretty_print(\"orders check for null elements\", orders.isnull())\n"
] | [
[
"pandas.Series"
]
] |
csherwood-usgs/CoastCam | [
"aa4de7c02ee0d719d89f13409319a44dba5eb768"
] | [
"original_code/calibration.py"
] | [
"import datetime\nfrom pathlib import Path\n\nimport numpy as np\nimport scipy.io\n\n\nclass CameraCalibration(object):\n \"\"\"Camera calibration saved in .mat file and method to assemble Projective (P) martrix.\n\n Notes:\n - Inspired by example code + notes from CiRC which are derived from Hartley and Zisserman (20030.)\n - Asssumes calibration saved in .mat file\n\n Args:\n calibration_file (str): Path to camera calibration file.\n\n Attributes:\n fname (str): Name of camera calibration file\n serial_number (int): Camera serial number\n camera_number (str): Camera number (e.g. 'c5')\n calibration_date (datetime): Date of camera calibration\n coordinate_system (str): Coordinate system used for calibration (e.g. 'xyz')\n beta (np.ndarray): Camera extrinsic calibration\n x (across shore), y (longshore), z (vertical), azimuth, tilt, roll\n lcp (dict): Lens Calibration Profile structure, the intrinsic camera calibration\n P (np.ndarray): Matrix containing intrinsic and extrinsic calibration\n \"\"\"\n def __init__(self, calibration_file):\n calibration_file = Path(calibration_file)\n self.fname = calibration_file.name\n sn, cn, dc, cs, _ = self.fname.split('_')\n self.serial_number = int(sn)\n self.camera_number = cn\n self.calibration_date = datetime.datetime.strptime(dc, '%Y%m%d')\n self.coordinate_system = cs\n\n mat_data = scipy.io.loadmat(calibration_file)\n self.beta = mat_data['beta'][0]\n self.lcp = self._load_lcp(mat_data['lcp'])\n self.P = self._assembleP()\n\n def _load_lcp(self, lcp):\n \"\"\"Return dict of lcp from lcp loaded from mat file\"\"\"\n NU = lcp[0, 0][0][0][0]\n NV = lcp[0, 0][1][0][0]\n c0U = lcp[0, 0][2][0][0]\n c0V = lcp[0, 0][3][0][0]\n fx = lcp[0, 0][4][0][0]\n fy = lcp[0, 0][5][0][0]\n d1 = lcp[0, 0][6][0][0]\n d2 = lcp[0, 0][7][0][0]\n d3 = lcp[0, 0][8][0][0]\n t1 = lcp[0, 0][9][0][0]\n t2 = lcp[0, 0][10][0][0]\n r = lcp[0, 0][11][0, :]\n caltech_fname = lcp[0, 0][12][0]\n fr = lcp[0, 0][13][0, :]\n x = lcp[0, 0][14][0, :]\n y = lcp[0, 0][15][0, :]\n dx = lcp[0, 0][16][:, :]\n dy = lcp[0, 0][17][:, :]\n\n return {\n 'NU': NU,\n 'NV': NV,\n 'c0U': c0U,\n 'c0V': c0V,\n 'fx': fx,\n 'fy': fy,\n 'd1': d1,\n 'd2': d2,\n 'd3': d3,\n 't1': t1,\n 't2': t2,\n 'r': r,\n 'fr': fr,\n 'caltech_fname': caltech_fname,\n 'x': x,\n 'y': y,\n 'dx': dx,\n 'dy': dy\n }\n\n def __repr__(self):\n msg = (\n f'serial_number: {self.serial_number}\\n'\n f'camera_number: {self.camera_number}\\n'\n f'calibration_date: {self.calibration_date}\\n'\n f'coordinate_system: {self.coordinate_system}\\n'\n f'beta: {self.beta}\\n'\n f\"sum of lcp r: {np.nansum(self.lcp['r'])}\"\n )\n return msg\n\n def __str__(self):\n msg = (\n f'serial_number: {self.serial_number}, '\n f'camera_number: {self.camera_number}, '\n f'calibration_date: {self.calibration_date}, '\n f'coordinate_system: {self.coordinate_system}'\n )\n return msg\n\n def _assembleP(self):\n \"\"\"Assembles and returns Projective (P) matrix from LCP and Beta values.\n\n Notes:\n - Derived from lcpBeta2P.m + CiRN notes\n - K converts angle away from the center of view into camera coordinates\n - R describes the 3D viewing direction of camera compared to world coordinates\n - beta[:3] camera location in world coordinates (x,y,z)\n - beta[3::] camera orientation (azimuth, tilt, roll)\n\n Returns:\n P (np.ndarray): Projective matrix\n \"\"\"\n # K: intrinsic matrix, puts image in pixel units of the specific camera\n K = np.array([\n [self.lcp['fx'], 0, self.lcp['c0U']],\n [0, -self.lcp['fy'], self.lcp['c0V']],\n [0, 0, 1]\n ])\n # R: rotation matrix, puts image in camera orientation\n R = angle2R(\n self.beta[3],\n self.beta[4],\n self.beta[5]\n )\n # I: identify matrix augmented by camera center, puts image in camera coordinates\n IC = np.vstack((\n np.eye(3),\n -self.beta[:3]\n )).T\n KR = np.matmul(K, R)\n P = np.matmul(KR, IC)\n\n # Make the matrix homogenous, methods use homogenous coordinates for easier math\n # - normalize to make last element equal 1\n P = P/P[-1, -1]\n\n return P\n\n\ndef angle2R(azimuth, tilt, swing):\n \"\"\"Assembles and returns a rotation matrix R from azimuth, tilt, and swing (roll)\n\n Notes:\n - derived from angles2R.m by Costal Imaging Research Network and Oregon State University\n - From p 612 of Wolf, 1983\n\n Arguments:\n azimuth (float): Azimuth\n tilt (float): Tilt\n swith (float): swing\n\n Returns:\n R (np.ndarray): Rotation matrix\n \"\"\"\n a = azimuth\n t = tilt\n s = swing\n R = np.zeros((3, 3))\n\n R[0, 0] = np.cos(a) * np.cos(s) + np.sin(a) * np.cos(t) * np.sin(s)\n R[0, 1] = -np.cos(s) * np.sin(a) + np.sin(s) * np.cos(t) * np.cos(a)\n R[0, 2] = np.sin(s) * np.sin(t)\n\n R[1, 0] = -np.sin(s) * np.cos(a) + np.cos(s) * np.cos(t) * np.sin(a)\n R[1, 1] = np.sin(s) * np.sin(a) + np.cos(s) * np.cos(t) * np.cos(a)\n R[1, 2] = np.cos(s) * np.sin(t)\n\n R[2, 0] = np.sin(t) * np.sin(a)\n R[2, 1] = np.sin(t) * np.cos(a)\n R[2, 2] = -np.cos(t)\n\n return R\n"
] | [
[
"numpy.eye",
"numpy.matmul",
"numpy.zeros",
"numpy.cos",
"numpy.nansum",
"numpy.array",
"numpy.sin"
]
] |
fcole90/interactive_bayesian_optimization | [
"a7aabdd22e84e89e4e1a1c13afee2ba13cad2eb5"
] | [
"interactive_bayesian_optimisation/libs/io.py"
] | [
"\"\"\"Functions for input/output\"\"\"\n\nimport os\nimport logging\nfrom interactive_bayesian_optimisation import config\nfrom interactive_bayesian_optimisation.libs import utils\n\nimport numpy as np\nfrom flask import json\nimport simplejson.errors\nimport yaml\n\n\ndef get_file_item_max(file_dir, min_val=0):\n # Adding -1 to the list, allows to always find a max\n file_id_list = [int(session_id.split(\".\")[0]) for session_id in os.listdir(file_dir)] + [min_val - 1]\n return int(np.max(file_id_list))\n\n\ndef ensure_savedir_exists(save_dir=None, study_name=None, sub_path=None):\n if sub_path is None:\n os.makedirs(config.get_study_save_dir(save_dir, study_name), exist_ok=True)\n else:\n os.makedirs(os.path.join(config.get_study_save_dir(save_dir, study_name), sub_path), exist_ok=True)\n\n\ndef get_new_user_id(save_dir=None, study_name=None):\n study_dir = config.get_study_save_dir(save_dir, study_name)\n ensure_savedir_exists(save_dir, study_name)\n new_id = get_file_item_max(study_dir) + 1\n\n return str(new_id)\n\n\ndef get_new_session_id(user_id=None, save_dir=None, study_name=None):\n study_dir = os.path.join(config.get_study_save_dir(save_dir, study_name), str(user_id))\n ensure_savedir_exists(save_dir, study_name, str(user_id))\n new_id = get_file_item_max(study_dir) + 1\n\n return str(new_id)\n\n\ndef load_data(user_id, session_id, save_dir=None, study_name=None):\n study_dir = os.path.join(config.get_study_save_dir(save_dir, study_name), str(user_id))\n session_filename = str(session_id) + \".save.json\"\n session_file_path = os.path.join(study_dir, session_filename)\n with open(session_file_path, \"r\") as session_file:\n try:\n return json.load(session_file)\n except simplejson.errors.JSONDecodeError as e:\n logging.error(\"Possibly malformed JSON string:\\n\\n\"\n \"-----------------------------------\\n\"\n \"{}\\n\"\n \"-----------------------------------\".format(session_file.read()))\n raise e\n\n\n\ndef save_data(data, user_id, session_id, save_dir=None, study_name=None, incremental=False, override_name=None):\n extension = \".save.json\"\n study_dir = os.path.join(config.get_study_save_dir(save_dir, study_name), str(user_id))\n session_filename = str(session_id) + (\"\" if override_name is None else override_name)\n session_file_path = os.path.join(study_dir, session_filename)\n\n # Save JSONS in a list of JSON objects\n if incremental == False:\n session_file_path += extension\n\n if os.path.exists(session_file_path):\n save_data_list = load_data(user_id, session_id, study_name=study_name)\n else:\n save_data_list = list()\n\n save_data_list.append(data)\n\n with open(session_file_path, \"w\") as session_file:\n session_file.write(utils.remove_nan(json.dumps(save_data_list)))\n\n # Save JSON in a folder of JSON files (one per iteration)\n else: # incremental == True:\n ensure_savedir_exists(save_dir, study_name, os.path.join(str(user_id), str(session_id)))\n new_save_name = get_file_item_max(session_file_path) + 1\n session_file_path = os.path.join(session_file_path, str(new_save_name) + extension)\n with open(session_file_path, \"w\") as session_file:\n session_file.write(utils.remove_nan(json.dumps(data)))\n\n\n\n\ndef load_settings(settings_file_name):\n settings_file_path = os.path.join(config.SETTINGS_PATH, settings_file_name + \".yaml\")\n if os.path.exists(settings_file_path):\n with open(settings_file_path) as settings_file_name:\n return yaml.load(settings_file_name)\n else:\n logging.warning(\"Settings file {} was not found in {}.\".format(settings_file_name, config.SETTINGS_PATH))\n with open(os.path.join(config.SETTINGS_PATH, \"default.yaml\")) as settings_file_name:\n return yaml.load(settings_file_name)"
] | [
[
"numpy.max"
]
] |
BlairLee/dataset-insights | [
"892e2ed3a2facf97cfa3a883700830d959a0c49b"
] | [
"datasetinsights/estimators/deeplab.py"
] | [
"import copy\nimport logging\n\nimport numpy as np\nimport torch\nimport torchvision\nfrom ignite.metrics import Loss\nfrom torchvision import transforms as T\nfrom torchvision.transforms import functional as F\n\nimport datasetinsights.constants as const\nfrom datasetinsights.data.datasets import Dataset\nfrom datasetinsights.data.loader import create_loader\nfrom datasetinsights.data.transforms import Compose, RandomHorizontalFlip\nfrom datasetinsights.evaluation_metrics import EvaluationMetric\nfrom datasetinsights.visualization.plots import decode_segmap, grid_plot\n\nfrom .base import Estimator\n\nlogger = logging.getLogger(__name__)\n\n# Normalization constants (heuristics) from ImageNet dataset\n_IMGNET_MEAN = (0.485, 0.456, 0.406)\n_IMGNET_STD = (0.229, 0.224, 0.225)\n\n# Inverse Normalization constants\n_INV_IMGNET_MEAN = (-0.485 / 0.229, -0.456 / 0.224, -0.406 / 0.225)\n_INV_IMGNET_STD = (1.0 / 0.229, 1.0 / 0.224, 1.0 / 0.5)\n\n\ndef pad_if_smaller(img, size, fill=0):\n min_size = min(img.size)\n if min_size < size:\n ow, oh = img.size\n padh = size - oh if oh < size else 0\n padw = size - ow if ow < size else 0\n img = F.pad(img, (0, 0, padw, padh), fill=fill)\n\n return img\n\n\nclass RandomCrop:\n def __init__(self, size):\n self.size = size\n\n def __call__(self, image, target):\n image = pad_if_smaller(image, self.size)\n target = pad_if_smaller(target, self.size, fill=255)\n crop_params = T.RandomCrop.get_params(image, (self.size, self.size))\n image = F.crop(image, *crop_params)\n target = F.crop(target, *crop_params)\n\n return image, target\n\n\nclass ToTensor:\n \"\"\"Convert a pair of (image, target) to tensor\n \"\"\"\n\n def __call__(self, image, target):\n image = F.to_tensor(image)\n target = torch.as_tensor(np.asarray(target), dtype=torch.int64)\n\n return image, target\n\n\nclass Normalize:\n def __init__(self, mean, std):\n self.mean = mean\n self.std = std\n\n def __call__(self, image, target):\n image = F.normalize(image, mean=self.mean, std=self.std)\n\n return image, target\n\n\nclass DeeplabV3(Estimator):\n \"\"\" DeeplabV3 Model https://arxiv.org/abs/1706.05587\n\n Args:\n config (CfgNode): estimator config\n writer: Tensorboard writer object\n checkpointer: Model checkpointer callback to save models\n device: model training on device (cpu|cuda)\n Attributes:\n backbone: model backbone (resnet50|resnet101)\n num_classes: number of classes for semantic segmentation\n model: tensorflow or pytorch graph\n writer: Tensorboard writer object\n checkpointer: Model checkpointer callback to save models\n device: model training on device (cpu|cuda)\n optimizer: pytorch optimizer\n lr_scheduler: pytorch learning rate scheduler\n \"\"\"\n\n def __init__(self, *, config, writer, checkpointer, device, **kwargs):\n self.config = config\n\n self.backbone = config.backbone\n self.num_classes = config.num_classes\n\n model_name = \"deeplabv3_\" + self.backbone\n self.model = torchvision.models.segmentation.__dict__[model_name](\n num_classes=self.num_classes\n )\n\n self.writer = writer\n self.checkpointer = checkpointer\n self.device = device\n\n opname = config.optimizer.name\n if opname == \"Adam\":\n optimizer = torch.optim.Adam(\n self.model.parameters(), **config.optimizer.args\n )\n\n # use fixed learning rate when using Adam\n lr_scheduler = torch.optim.lr_scheduler.LambdaLR(\n optimizer, lambda x: 1.0\n )\n else:\n raise ValueError(f\"Unsupported optimizer type {opname}\")\n\n self.optimizer = optimizer\n self.lr_scheduler = lr_scheduler\n\n # load estimators from file if checkpoint_file exists\n ckpt_file = config.checkpoint_file\n if ckpt_file != const.NULL_STRING:\n checkpointer.load(self, ckpt_file)\n\n @staticmethod\n def _transforms(is_train=True, crop_size=769):\n \"\"\"Transformations for a pair of input and target image\n\n Args:\n is_train (bool): indicator whether this is a transformation\n during training (default: True)\n crop_size (int): crop size. Images will be cropped to\n (crop_size, crop_size)\n \"\"\"\n transforms = []\n if is_train:\n transforms.append(RandomHorizontalFlip(0.5))\n transforms.append(RandomCrop(crop_size))\n transforms.append(ToTensor())\n transforms.append(Normalize(mean=_IMGNET_MEAN, std=_IMGNET_STD))\n\n return Compose(transforms)\n\n @staticmethod\n def _loss_fn(outputs, target):\n \"\"\" Compute loss\n\n Args:\n outputs (dict): named output of deeplabv3 model. Since this\n implementation outpus two semantic segmentation images from two\n heads of the model, we are expecting dict of tow keys\n \"out\" and \"aux\" that corresponds to two pytorch tenor of images.\n target (torch.Tensor): ground truth 2D image tensor\n\n Returns:\n numerical value of loss\n \"\"\"\n losses = {}\n for name, x in outputs.items():\n losses[name] = torch.nn.functional.cross_entropy(\n x, target, ignore_index=255\n )\n\n if len(losses) == 1:\n return losses[\"out\"]\n\n return losses[\"out\"] + 0.5 * losses[\"aux\"]\n\n def _train_one_epoch(self, loader, epoch):\n \"\"\" Train one epoch\n\n Args:\n loader (DataLoader): pytorch dataloader\n epoch (int): the current epoch number\n \"\"\"\n logger.info(f\"Epoch[{epoch}] training started.\")\n self.model.train()\n n_batch = len(loader)\n accumulation_steps = self.config.train.accumulation_steps\n loss_metric = Loss(self._loss_fn)\n\n self.optimizer.zero_grad()\n for i, (image, target) in enumerate(loader):\n image, target = image.to(self.device), target.to(self.device)\n output = self.model(image)\n loss = self._loss_fn(output, target)\n loss.backward()\n\n # Accumulated Gradients are only updated after X steps.\n # This creates an effective batch size of\n # batch_size * accumulation_steps\n if (i + 1) % accumulation_steps == 0:\n self.optimizer.step()\n self.lr_scheduler.step()\n self.optimizer.zero_grad()\n\n loss_metric.update((output, target))\n\n iter_num = (i + 1) % n_batch\n logger.debug(\n f\"Epoch[{epoch}] Iteration[{iter_num}/{n_batch}] \"\n f\"Loss: {loss:.3f}\"\n )\n\n epoch_loss = loss_metric.compute()\n logger.info(\n f\"Epoch[{epoch}] training completed. Loss: {epoch_loss:.3f}\"\n )\n self.writer.add_scalar(\"training/loss\", epoch_loss, epoch)\n\n loss_metric.reset()\n\n def _evaluate_one_epoch(self, loader, epoch):\n \"\"\" Evaluate one epoch\n\n Args:\n loader (DataLoader): pytorch dataloader\n epoch (int): the current epoch number\n \"\"\"\n logger.info(f\"Epoch[{epoch}] evaluation started\")\n self.model.eval()\n loss_metric = Loss(self._loss_fn)\n\n # TODO: Support other metrics other than IoU and support multiple\n # mettics\n iou_metric = EvaluationMetric.create(\n self.config.metric, num_classes=self.num_classes\n )\n with torch.no_grad():\n for image, target in loader:\n image, target = image.to(self.device), target.to(self.device)\n output = self.model(image)\n\n loss_metric.update((output, target))\n iou_metric.update((output[\"out\"], target))\n\n loss = loss_metric.compute()\n iou = iou_metric.compute()\n\n # some classes are not used in cityscapes evaluation.\n # TODO: Move class masking logic to IoU metric class.\n keep_mask = [\n not c.ignore_in_eval\n for c in torchvision.datasets.Cityscapes.classes\n ]\n class_names = [c.name for c in torchvision.datasets.Cityscapes.classes]\n iou_info = {\n name: f\"{iou[i].item():.3f}\"\n for i, name in enumerate(class_names)\n if keep_mask[i]\n }\n miou = iou[keep_mask].mean()\n\n logger.info(\n f\"Epoch[{epoch}] evaluation completed. \"\n f\"Loss: {loss:.3f}, mIoU: {miou:.3f}\\n\"\n f\"IoU per class: {iou_info}\"\n )\n self.writer.add_scalar(\"validation/loss\", loss, epoch)\n self.writer.add_scalar(\"validation/miou\", miou, epoch)\n\n inv_normalize = T.Normalize(mean=_INV_IMGNET_MEAN, std=_INV_IMGNET_STD)\n # Visualize segmentation images from last mini-batch\n n_images = list(image.shape)[0]\n image_grid = []\n for i in range(n_images):\n img = inv_normalize(image[i, :]).permute(1, 2, 0).cpu().numpy()\n out = decode_segmap(output[\"out\"][i, :].max(0)[1].cpu().numpy())\n tgt = decode_segmap(target[i, :].cpu().numpy())\n image_grid.append([img, out, tgt])\n\n fig = grid_plot(image_grid)\n self.writer.add_figure(\"validation/visualize\", fig, epoch)\n\n loss_metric.reset()\n iou_metric.reset()\n\n def train(self, **kwargs):\n config = self.config\n train_dataset = Dataset.create(\n config.train.dataset,\n split=\"train\",\n data_root=config.system.data_root,\n transforms=self._transforms(\n is_train=True, crop_size=config.train.crop_size\n ),\n )\n train_loader = create_loader(\n train_dataset,\n batch_size=config.train.batch_size,\n num_workers=config.system.workers,\n dryrun=config.system.dryrun,\n )\n\n val_dataset = Dataset.create(\n config.val.dataset,\n split=\"val\",\n data_root=config.system.data_root,\n transforms=self._transforms(is_train=False),\n )\n val_loader = create_loader(\n val_dataset,\n batch_size=config.val.batch_size,\n num_workers=config.system.workers,\n dryrun=config.system.dryrun,\n )\n\n logger.info(\"Start training estimator: %s\", type(self).__name__)\n self.model.to(self.device)\n n_epochs = config.train.epochs\n val_interval = config.system.val_interval\n for epoch in range(1, n_epochs + 1):\n logger.info(f\"Training Epoch[{epoch}/{n_epochs}]\")\n self._train_one_epoch(train_loader, epoch)\n\n if epoch % val_interval == 0:\n self._evaluate_one_epoch(val_loader, epoch)\n\n self.checkpointer.save(self, epoch=epoch)\n\n def evaluate(self, **kwargs):\n config = self.config\n test_dataset = Dataset.create(\n config.test.dataset,\n split=\"test\",\n data_root=config.system.data_root,\n transforms=self._transforms(is_train=False),\n )\n test_loader = create_loader(\n test_dataset,\n batch_size=config.test.batch_size,\n num_workers=config.system.workers,\n dryrun=config.system.dryrun,\n )\n\n logger.info(\"Start evaluating estimator: %s\", type(self).__name__)\n self.model.to(self.device)\n self._evaluate_one_epoch(test_loader, epoch=1)\n\n def save(self, path):\n \"\"\" Serialize Estimator to path\n\n Args:\n path (str): full path to save serialized estimator\n\n Returns:\n saved full path of the serialized estimator\n \"\"\"\n save_dict = {\"model\": self.model.state_dict(), \"config\": self.config}\n torch.save(save_dict, path)\n\n return path\n\n def load(self, path):\n \"\"\" Load Estimator from path\n\n Args:\n path (str): full path to the serialized estimator\n \"\"\"\n checkpoint = torch.load(path)\n self.model.load_state_dict(checkpoint[\"model\"])\n\n loaded_config = copy.deepcopy(checkpoint[\"config\"])\n stored_config = copy.deepcopy(self.config)\n del stored_config[\"checkpoint_file\"]\n del loaded_config[\"checkpoint_file\"]\n if stored_config != loaded_config:\n logger.warning(\n f\"Found difference in estimator config.\"\n f\"Estimator loaded from {path} was trained using \"\n f\"config: \"\n f\"{loaded_config}. However, the current config is: \"\n f\"{self.config}.\"\n )\n"
] | [
[
"torch.load",
"torch.optim.lr_scheduler.LambdaLR",
"torch.save",
"torch.no_grad",
"numpy.asarray",
"torch.nn.functional.cross_entropy"
]
] |
pirun/waveform_analysis | [
"66809614b1fc985e694af1720341035316a5ac8e"
] | [
"waveform_analysis/_common.py"
] | [
"#!/usr/bin/env python\n\nfrom numpy import array_equal, polyfit, sqrt, mean, absolute, log10, arange\nimport numpy as np\nfrom scipy.stats import gmean\n\ntry:\n from soundfile import SoundFile\n wav_loader = 'pysoundfile'\nexcept:\n try:\n from scikits.audiolab import Sndfile\n wav_loader = 'scikits.audiolab'\n except:\n try:\n from scipy.io.wavfile import read\n wav_loader = 'scipy.io.wavfile'\n except:\n raise ImportError('No sound file loading package installed '\n '(PySoundFile, scikits.audiolab, or SciPy)')\n\n\ndef load(filename):\n \"\"\"\n Load a wave file and return the signal, sample rate and number of channels.\n\n Can be any format supported by the underlying library (libsndfile or SciPy)\n \"\"\"\n if wav_loader == 'pysoundfile':\n sf = SoundFile(filename)\n signal = sf.read()\n channels = sf.channels\n sample_rate = sf.samplerate\n sf.close()\n elif wav_loader == 'scikits.audiolab':\n sf = Sndfile(filename, 'r')\n signal = sf.read_frames(sf.nframes)\n channels = sf.channels\n sample_rate = sf.samplerate\n sf.close()\n elif wav_loader == 'scipy.io.wavfile':\n sample_rate, signal = read(filename)\n try:\n channels = signal.shape[1]\n except IndexError:\n channels = 1\n\n return signal, sample_rate, channels\n\n\ndef load_dict(filename):\n \"\"\"\n Load a wave file and return the signal, sample rate and number of channels.\n\n Can be any format supported by the underlying library (libsndfile or SciPy)\n \"\"\"\n soundfile = {}\n if wav_loader == 'pysoundfile':\n sf = SoundFile(filename)\n soundfile['signal'] = sf.read()\n soundfile['channels'] = sf.channels\n soundfile['fs'] = sf.samplerate\n soundfile['samples'] = len(sf)\n soundfile['format'] = sf.format_info + ' ' + sf.subtype_info\n sf.close()\n elif wav_loader == 'scikits.audiolab':\n sf = Sndfile(filename, 'r')\n soundfile['signal'] = sf.read_frames(sf.nframes)\n soundfile['channels'] = sf.channels\n soundfile['fs'] = sf.samplerate\n soundfile['samples'] = sf.nframes\n soundfile['format'] = sf.format\n sf.close()\n elif wav_loader == 'scipy.io.wavfile':\n soundfile['fs'], soundfile['signal'] = read(filename)\n try:\n soundfile['channels'] = soundfile['signal'].shape[1]\n except IndexError:\n soundfile['channels'] = 1\n soundfile['samples'] = soundfile['signal'].shape[0]\n soundfile['format'] = str(soundfile['signal'].dtype)\n\n return soundfile\n\n\ndef analyze_channels(filename, function):\n \"\"\"\n Given a filename, run the given analyzer function on each channel of the\n file\n \"\"\"\n signal, sample_rate, channels = load(filename)\n print('Analyzing \"' + filename + '\"...')\n\n if channels == 1:\n # Monaural\n function(signal, sample_rate)\n elif channels == 2:\n # Stereo\n if array_equal(signal[:, 0], signal[:, 1]):\n print('-- Left and Right channels are identical --')\n function(signal[:, 0], sample_rate)\n else:\n print('-- Left channel --')\n function(signal[:, 0], sample_rate)\n print('-- Right channel --')\n function(signal[:, 1], sample_rate)\n else:\n # Multi-channel\n for ch_no, channel in enumerate(signal.transpose()):\n print('-- Channel %d --' % (ch_no + 1))\n function(channel, sample_rate)\n\n\n# Copied from matplotlib.mlab:\n\ndef rms_flat(a):\n \"\"\"\n Return the root mean square of all the elements of *a*, flattened out.\n \"\"\"\n return sqrt(mean(absolute(a)**2))\n\n\ndef find(condition):\n \"Return the indices where ravel(condition) is true\"\n res, = np.nonzero(np.ravel(condition))\n return res\n\n\ndef dB(q):\n \"\"\"\n Return the level of a field quantity in decibels.\n \"\"\"\n return 20 * log10(q)\n\n\ndef spectral_flatness(spectrum):\n \"\"\"\n The spectral flatness is calculated by dividing the geometric mean of\n the power spectrum by the arithmetic mean of the power spectrum\n\n I'm not sure if the spectrum should be squared first...\n \"\"\"\n return gmean(spectrum)/mean(spectrum)\n\n\ndef parabolic(f, x):\n \"\"\"\n Quadratic interpolation for estimating the true position of an\n inter-sample maximum when nearby samples are known.\n\n f is a vector and x is an index for that vector.\n\n Returns (vx, vy), the coordinates of the vertex of a parabola that goes\n through point x and its two neighbors.\n\n Example:\n Defining a vector f with a local maximum at index 3 (= 6), find local\n maximum if points 2, 3, and 4 actually defined a parabola.\n\n In [3]: f = [2, 3, 1, 6, 4, 2, 3, 1]\n\n In [4]: parabolic(f, argmax(f))\n Out[4]: (3.2142857142857144, 6.1607142857142856)\n \"\"\"\n if int(x) != x:\n raise ValueError('x must be an integer sample index')\n else:\n x = int(x)\n xv = 1/2. * (f[x-1] - f[x+1]) / (f[x-1] - 2 * f[x] + f[x+1]) + x\n yv = f[x] - 1/4. * (f[x-1] - f[x+1]) * (xv - x)\n return (xv, yv)\n\n\ndef parabolic_polyfit(f, x, n):\n \"\"\"\n Use the built-in polyfit() function to find the peak of a parabola\n\n f is a vector and x is an index for that vector.\n\n n is the number of samples of the curve used to fit the parabola.\n \"\"\"\n a, b, c = polyfit(arange(x-n//2, x+n//2+1), f[x-n//2:x+n//2+1], 2)\n xv = -0.5 * b/a\n yv = a * xv**2 + b * xv + c\n return (xv, yv)\n"
] | [
[
"scipy.stats.gmean",
"numpy.ravel",
"numpy.arange",
"numpy.log10",
"scipy.io.wavfile.read",
"numpy.absolute",
"numpy.array_equal",
"numpy.mean"
]
] |
luxufan/CS131_release | [
"e8a92582cfffee3ba6bb43f757bcb520785b6f04"
] | [
"hw1_release/filters.py"
] | [
"\"\"\"\nCS131 - Computer Vision: Foundations and Applications\nAssignment 1\nAuthor: Donsuk Lee ([email protected])\nDate created: 07/2017\nLast modified: 10/16/2017\nPython Version: 3.5+\n\"\"\"\n\nimport numpy as np\n\n\ndef conv_nested(image, kernel):\n \"\"\"A naive implementation of convolution filter.\n\n This is a naive implementation of convolution using 4 nested for-loops.\n This function computes convolution of an image with a kernel and outputs\n the result that has the same shape as the input image.\n\n Args:\n image: numpy array of shape (Hi, Wi).\n kernel: numpy array of shape (Hk, Wk).\n\n Returns:\n out: numpy array of shape (Hi, Wi).\n \"\"\"\n Hi, Wi = image.shape\n Hk, Wk = kernel.shape\n out = np.zeros((Hi, Wi))\n\n ### YOUR CODE HERE\n for i in range(Hi):\n for j in range(Wi):\n sum = 0\n for ii in range(-(Hk//2), Hk//2 + 1):\n for jj in range(-(Wk//2), Wk//2 + 1):\n sum += image[i - ii, j - jj] * kernel[ii + Hk // 2, jj + Wk // 2] \\\n if 0 <= i - ii < Hi and 0 <= j - jj < Wi else 0\n out[i, j] = sum\n ### END YOUR CODE\n\n return out\n\ndef zero_pad(image, pad_height, pad_width):\n \"\"\" Zero-pad an image.\n\n Ex: a 1x1 image [[1]] with pad_height = 1, pad_width = 2 becomes:\n\n [[0, 0, 0, 0, 0],\n [0, 0, 1, 0, 0],\n [0, 0, 0, 0, 0]] of shape (3, 5)\n\n Args:\n image: numpy array of shape (H, W).\n pad_width: width of the zero padding (left and right padding).\n pad_height: height of the zero padding (bottom and top padding).\n\n Returns:\n out: numpy array of shape (H+2*pad_height, W+2*pad_width).\n \"\"\"\n\n H, W = image.shape\n out = None\n\n ### YOUR CODE HERE\n out = np.pad(image, ((pad_height, pad_height), (pad_width, pad_width)), 'constant', constant_values = (0))\n pass\n ### END YOUR CODE\n return out\n\n\ndef conv_fast(image, kernel):\n \"\"\" An efficient implementation of convolution filter.\n\n This function uses element-wise multiplication and np.sum()\n to efficiently compute weighted sum of neighborhood at each\n pixel.\n\n Hints:\n - Use the zero_pad function you implemented above\n - There should be two nested for-loops\n - You may find np.flip() and np.sum() useful\n\n Args:\n image: numpy array of shape (Hi, Wi).\n kernel: numpy array of shape (Hk, Wk).\n\n Returns:\n out: numpy array of shape (Hi, Wi).\n \"\"\"\n Hi, Wi = image.shape\n Hk, Wk = kernel.shape\n out = np.zeros((Hi, Wi))\n\n ### YOUR CODE HERE\n image_pad = zero_pad(image, Hk // 2, Wk // 2)\n kernel_flip = np.flip(np.flip(kernel, axis=0), axis=1)\n for i in range(Hi):\n for j in range(Wi):\n out[i, j] = np.sum(image_pad[i:i + Hk, j:j + Wk] * kernel_flip)\n ### END YOUR CODE\n\n return out\n\ndef conv_faster(image, kernel):\n \"\"\"\n Args:\n image: numpy array of shape (Hi, Wi).\n kernel: numpy array of shape (Hk, Wk).\n\n Returns:\n out: numpy array of shape (Hi, Wi).\n \"\"\"\n Hi, Wi = image.shape\n Hk, Wk = kernel.shape\n out = np.zeros((Hi, Wi))\n\n ### YOUR CODE HERE\n out = image.copy()\n u, s, v = np.linalg.svd(kernel)\n kernel_u = (u.T[s > 1e-6]).T\n kernel_v = (v[s > 1e-6])\n for p in range(np.sum(s > 1e-6)):\n out = conv_fast(out, (kernel_u[:, p] * s[p]).reshape(Hk, 1))\n out = conv_fast(out, kernel_v[p].reshape(1, Wk))\n ### END YOUR CODE\n\n return out\n\ndef cross_correlation(f, g):\n \"\"\" Cross-correlation of f and g.\n\n Hint: use the conv_fast function defined above.\n\n Args:\n f: numpy array of shape (Hf, Wf).\n g: numpy array of shape (Hg, Wg).\n\n Returns:\n out: numpy array of shape (Hf, Wf).\n \"\"\"\n\n out = None\n ### YOUR CODE HERE\n out = conv_fast(f, np.flip(np.flip(g, axis=0), axis=1))\n ### END YOUR CODE\n\n return out\n\ndef zero_mean_cross_correlation(f, g):\n \"\"\" Zero-mean cross-correlation of f and g.\n\n Subtract the mean of g from g so that its mean becomes zero.\n\n Hint: you should look up useful numpy functions online for calculating the mean.\n\n Args:\n f: numpy array of shape (Hf, Wf).\n g: numpy array of shape (Hg, Wg).\n\n Returns:\n out: numpy array of shape (Hf, Wf).\n \"\"\"\n\n out = None\n ### YOUR CODE HERE\n zero_mean_g = g - np.mean(g)\n zero_mean_f = f - np.mean(g)\n out = conv_fast(zero_mean_f, np.flip(np.flip(zero_mean_g, axis=0), axis=1))\n ### END YOUR CODE\n\n return out\n\ndef normalized_cross_correlation(f, g):\n \"\"\" Normalized cross-correlation of f and g.\n\n Normalize the subimage of f and the template g at each step\n before computing the weighted sum of the two.\n\n Hint: you should look up useful numpy functions online for calculating\n the mean and standard deviation.\n\n Args:\n f: numpy array of shape (Hf, Wf).\n g: numpy array of shape (Hg, Wg).\n\n Returns:\n out: numpy array of shape (Hf, Wf).\n \"\"\"\n\n out = None\n ### YOUR CODE HERE\n Hf, Wf = f.shape\n out = np.zeros((Hf, Wf))\n g = g[:-1, :] if g.shape[0] % 2 == 0 else g\n g = g[:, :-1] if g.shape[1] % 2 == 0 else g\n Hg, Wg = g.shape\n normalized_filter = (g - np.mean(g)) / np.std(g)\n f = zero_pad(f, Hg // 2, Wg // 2)\n for i in range(Hf):\n for j in range(Wf):\n normalized_template = (f[i:i+Hg, j:j+Wg] - np.mean(f[i:i+Hg, j:j+Wg])) / np.std(f[i:i+Hg, j:j+Wg])\n out[i, j] = np.sum(normalized_template * g)\n ### END YOUR CODE\n\n return out\n"
] | [
[
"numpy.sum",
"numpy.zeros",
"numpy.linalg.svd",
"numpy.flip",
"numpy.std",
"numpy.pad",
"numpy.mean"
]
] |
aaryapatil/specdims | [
"acfc644aa06b13c8b34cde984e207b42e948af41"
] | [
"delfiSpec/specproc.py"
] | [
"# Import dependencies\nimport numpy as np\nfrom apogee.spec import continuum\nfrom apogee.tools import bitmask as bm\n\nfrom .util import get_DR_slice, bitsNotSet\n\n# Future: Define a class for spectra - spectra, error and weight\n\ndef process_spectra(spectra_info=None, badcombpixmask=4351, minSNR=50.):\n cont_cannon = continuum.fit(spectra_info[:, 0], spectra_info[:, 1], type='cannon')\n\n spectra_info[:, 0] = spectra_info[:, 0]/cont_cannon\n spectra_info[:, 1] = spectra_info[:, 1]/cont_cannon\n\n # Get DR indices\n spec = get_DR_slice(spectra_info[:, 0])\n spec_err = get_DR_slice(spectra_info[:, 1])\n bitmask = (get_DR_slice(spectra_info[:, 2])).astype('int')\n\n maskbits = bm.bits_set(badcombpixmask)\n # Mask where SNR low or where something flagged in bitmask\n mask = (spec/spec_err < minSNR) | bitsNotSet(bitmask, maskbits)\n\n # Errors below 0.005 in APOGEE are not trusted \n spec_err[spec_err<0.005] = 0.005\n \n try:\n weight = 1.0 / spec_err**2\n except:\n # Handling zero errors\n zero_errors = np.where(spec_err==0)\n listOfCoordinates= list(zip(zero_errors[0], zero_errors[1]))\n for cord in listOfCoordinates:\n spec_err[cord] = np.median(spec_err)\n\n weight = 1.0 / spec_err**2\n\n np.place(weight, mask, 0)\n return np.squeeze(spec), np.squeeze(spec_err), np.squeeze(weight)"
] | [
[
"numpy.where",
"numpy.place",
"numpy.median",
"numpy.squeeze"
]
] |
yhCyan/graph-tensor-propagation | [
"b216fb24c5b9ea21d7b338ac24b272b0f346fcc3"
] | [
"exp_gqa/main.py"
] | [
"import os\nimport json\nimport torch\nimport sys\nimport time\nimport random\nimport numpy as np\n\nfrom tqdm import tqdm, trange\nimport torch.multiprocessing as mp\nimport torch.distributed as dist\nfrom torch.utils.tensorboard import SummaryWriter\nfrom apex.parallel import DistributedDataParallel as DDP\nfrom apex import amp\n\nsys.path.append('..')\nfrom models_gqa.model import LCGNwrapper\nfrom models_gqa.config import build_cfg_from_argparse\nfrom util.gqa_train.data_reader import DataReader\n#from util.gqa_train.data_reader import gqa_convert_examples_to_features\n# Load config\n# cmd = '--cfg /home/xdjf/lcgn-pytorch/exp_gqa/cfgs/lcgn_spatial.yaml train True'.split()\n# sys.argv.extend(cmd)\n\n# Start session\n#os.environ[\"CUDA_VISIBLE_DEVICES\"] = cfg.GPUS\n# if len(cfg.GPUS.split(',')) > 1:\n# print('PyTorch implementation currently only supports single GPU')\nimport wandb\n\n\ndef load_train_data(cfg, rank, gpu, max_num=0, num_replicas=1):\n imdb_file = cfg.IMDB_FILE % cfg.TRAIN.SPLIT_VQA\n scene_graph_file = cfg.SCENE_GRAPH_FILE % \\\n cfg.TRAIN.SPLIT_VQA.replace('_balanced', '').replace('_all', '')\n #a = gqa_convert_examples_to_features(imdb_file, scene_graph_file, cfg)\n\n data_reader = DataReader(\n imdb_file, rank, gpu, num_replicas, shuffle=True, max_num=max_num,\n batch_size=cfg.TRAIN.BATCH_SIZE,\n vocab_question_file=cfg.VOCAB_QUESTION_FILE,\n T_encoder=cfg.T_ENCODER,\n N_encoder=cfg.N_ENCODER,\n O_encoder = cfg.O_ENCODER,\n vocab_answer_file=cfg.VOCAB_ANSWER_FILE,\n feature_type=cfg.FEAT_TYPE,\n spatial_feature_dir=cfg.SPATIAL_FEATURE_DIR,\n objects_feature_dir=cfg.OBJECTS_FEATURE_DIR,\n objects_max_num=cfg.W_FEAT,\n scene_graph_file=scene_graph_file,\n vocab_name_file=cfg.VOCAB_NAME_FILE,\n vocab_attr_file=cfg.VOCAB_ATTR_FILE,\n add_pos_enc=cfg.ADD_POS_ENC,\n pos_enc_dim=cfg.PE_DIM, \n pos_enc_scale=cfg.PE_SCALE)\n num_vocab = data_reader.batch_loader.vocab_dict.num_vocab\n num_choices = data_reader.batch_loader.answer_dict.num_vocab\n return data_reader, num_vocab, num_choices\n\n\ndef batch_to_data(batch):\n questionIndices = torch.from_numpy(\n batch['input_seq_batch'].astype(np.int64)).cuda() # 128 * 30\n questionLengths = torch.from_numpy(\n batch['seq_length_batch'].astype(np.int64)).cuda() # 128\n semanIndices = torch.from_numpy(\n batch['input_seman_batch'].astype(np.int64)).cuda() # 128 * 30\n semanLengths = torch.from_numpy(\n batch['seman_length_batch'].astype(np.int64)).cuda() # 128\n answerIndices = torch.from_numpy(\n batch['answer_label_batch'].astype(np.int64)).cuda() # 128\n nameIndices = torch.from_numpy(\n batch['input_name_batch'].astype(np.int64)).cuda()\n nameLengths = torch.from_numpy(\n batch['name_length_batch'].astype(np.int64)).cuda()\n images = torch.from_numpy(\n batch['image_feat_batch'].astype(np.float32)).cuda() # 128 * 49 * 2112\n imagesObjectNum = torch.from_numpy(\n np.sum(batch['image_valid_batch'].astype(np.int64), axis=1)).cuda() # 128\n\n\n return (questionIndices, questionLengths, semanIndices, semanLengths, answerIndices, nameIndices, nameLengths, images, imagesObjectNum)\n\ndef run_train_on_data(model, data_reader_train, cfg, rank, gpu, run_eval=False,\n data_reader_eval=None):\n model.train()\n\n global_step = 1\n lr = cfg.TRAIN.SOLVER.LR\n correct, total, loss_sum, batch_num = 0, 0, 0., 0\n tr_loss, logging_loss = 0.0, 0.0\n\n # if rank in [-1, 0]:\n # tb_writer = SummaryWriter()\n \n for batch, n_sample, e in data_reader_train.batches(one_pass=False):\n n_epoch = cfg.TRAIN.START_EPOCH + e\n if n_sample == 0 and n_epoch > cfg.TRAIN.START_EPOCH and rank in [-1, 0]:\n print('')\n # save snapshot\n snapshot_file = cfg.SNAPSHOT_FILE % (cfg.EXP_NAME, n_epoch)\n torch.save(model.state_dict(), snapshot_file)\n # run evaluation\n if run_eval:\n batch_eval = run_eval_on_data(cfg, model, data_reader_eval)\n #tb_writer.add_scalar(\"eval_loss\", batch_eval['loss'], global_step)\n model.train()\n if cfg.DEBUG == False:\n wandb.log({\"eval_loss\": batch_eval['loss'], \"eval_correct\": batch_eval['accuracy']})\n # clear stats\n correct, total, loss_sum, batch_num = 0, 0, 0., 0\n if n_epoch >= cfg.TRAIN.MAX_EPOCH:\n break\n\n batch_list = batch_to_data(batch)\n # if first and rank in [-1, 0]:\n # tb_writer.add_graph(model.model, (batch_list, ))\n # first = False\n \n batch_res = model.run_batch(batch_list, train=True, lr=lr)\n correct += batch_res['num_correct']\n total += batch_res['batch_size']\n loss_sum += batch_res['loss'].item()\n tr_loss += loss_sum\n batch_num += 1\n global_step += 1\n lr = batch_res['lr']\n \n if rank in [-1, 0] and cfg.logging_steps > 0 and global_step % cfg.logging_steps == 0 and cfg.DEBUG == False:\n wandb.log({\"lr\": batch_res['lr'], \"train_loss\": loss_sum/batch_num, \"train_correct\": correct/total})\n # tb_writer.add_scalar(\"lr\", batch_res['lr'], global_step)\n # tb_writer.add_scalar(\"loss\", (tr_loss - logging_loss) / cfg.logging_steps, global_step)\n\n if rank in [-1, 0]:\n print('\\rTrain E %d S %d: avgL=%.4f, avgA=%.4f, lr=%.1e' % (\n n_epoch+1, total, loss_sum/batch_num, correct/total, lr),\n end='')\n\n # if rank in [-1, 0]:\n # tb_writer.close()\n\n\ndef load_eval_data(cfg, rank, gpu, max_num=0):\n imdb_file = cfg.IMDB_FILE % cfg.TEST.SPLIT_VQA\n scene_graph_file = cfg.SCENE_GRAPH_FILE % \\\n cfg.TEST.SPLIT_VQA.replace('_balanced', '').replace('_all', '')\n data_reader = DataReader(\n imdb_file, rank, gpu, 1, shuffle=False, max_num=max_num,\n batch_size=cfg.TEST.BATCH_SIZE,\n vocab_question_file=cfg.VOCAB_QUESTION_FILE,\n T_encoder=cfg.T_ENCODER,\n N_encoder=cfg.N_ENCODER,\n O_encoder = cfg.O_ENCODER,\n vocab_answer_file=cfg.VOCAB_ANSWER_FILE,\n feature_type=cfg.FEAT_TYPE,\n spatial_feature_dir=cfg.SPATIAL_FEATURE_DIR,\n objects_feature_dir=cfg.OBJECTS_FEATURE_DIR,\n objects_max_num=cfg.W_FEAT,\n scene_graph_file=scene_graph_file,\n vocab_name_file=cfg.VOCAB_NAME_FILE,\n vocab_attr_file=cfg.VOCAB_ATTR_FILE,\n add_pos_enc=cfg.ADD_POS_ENC,\n pos_enc_dim=cfg.PE_DIM, pos_enc_scale=cfg.PE_SCALE)\n num_vocab = data_reader.batch_loader.vocab_dict.num_vocab\n num_choices = data_reader.batch_loader.answer_dict.num_vocab\n return data_reader, num_vocab, num_choices\n\n\ndef run_eval_on_data(cfg, model, data_reader_eval, pred=False):\n model.eval()\n predictions = []\n answer_tokens = data_reader_eval.batch_loader.answer_dict.word_list\n correct, total, loss_sum, batch_num = 0, 0, 0., 0\n for batch, _, _ in data_reader_eval.batches(one_pass=True):\n batch_list = batch_to_data(batch)\n batch_res = model.run_batch(batch_list, train=False)\n if pred:\n predictions.extend([\n {'questionId': q, 'prediction': answer_tokens[p]}\n for q, p in zip(batch['qid_list'], batch_res['predictions'])])\n correct += batch_res['num_correct']\n total += batch_res['batch_size']\n loss_sum += batch_res['loss'].item()\n batch_num += 1\n print('\\rEval S %d: avgL=%.4f, avgA=%.4f' % (\n total, loss_sum/batch_num, correct/total), end='')\n print('')\n eval_res = {\n 'correct': correct,\n 'total': total,\n 'accuracy': correct/total,\n 'loss': loss_sum/batch_num,\n 'predictions': predictions}\n return eval_res\n\n\ndef dump_prediction_to_file(cfg, predictions, res_dir):\n pred_file = os.path.join(res_dir, 'pred_%s_%04d_%s.json' % (\n cfg.EXP_NAME, cfg.TEST.EPOCH, cfg.TEST.SPLIT_VQA))\n with open(pred_file, 'w') as f:\n json.dump(predictions, f, indent=2)\n print('predictions written to %s' % pred_file)\n\n\ndef set_seed(args):\n random.seed(args.seed)\n np.random.seed(args.seed)\n torch.manual_seed(args.seed)\n if args.n_gpus > 0:\n torch.cuda.manual_seed_all(args.seed)\n\n\ndef train(gpu, cfg):\n\n rank = -1\n if gpu != -1:\n rank = cfg.nr * cfg.n_gpus + gpu\t \n dist.init_process_group( \n \tbackend='nccl', \n \t\tinit_method='env://', \n \tworld_size=cfg.world_size, \n \trank=rank \n ) \n if rank in [-1, 0, 1]:\n gpu = 0\n elif rank in [2, 3]:\n gpu = 1\n \n set_seed(cfg)\n\n print(f'rank: {rank} pid: {os.getpid()} is running...')\n num_replicas = cfg.world_size if rank != -1 else 1\n data_reader_train, num_vocab, num_choices = load_train_data(cfg, rank, gpu, num_replicas=num_replicas)\n data_reader_eval, _, _ = load_eval_data(cfg, rank, gpu, max_num=cfg.TRAIN.EVAL_MAX_NUM)\n # Load model\n\n model = LCGNwrapper(num_vocab, num_choices, cfg=cfg, rank=rank, gpu=gpu)\n # Save snapshot\n if rank in [-1, 0]:\n if cfg.DEBUG == False:\n name = time.strftime('%Y%m%d-%H%M%S')\n wandb.init(project=\"gtp\", notes=\"graph tensor propa\", name=name)\n wandb.watch(model.model, log=\"all\")\n wandb.config.update(cfg)\n snapshot_dir = os.path.dirname(cfg.SNAPSHOT_FILE % (cfg.EXP_NAME, 0))\n os.makedirs(snapshot_dir, exist_ok=True)\n with open(os.path.join(snapshot_dir, 'cfg.json'), 'w') as f:\n json.dump(cfg, f, indent=2)\n if cfg.TRAIN.START_EPOCH > 0 and rank in [-1, 0]:\n print('resuming from epoch %d' % cfg.TRAIN.START_EPOCH)\n model.load_state_dict(torch.load(\n cfg.SNAPSHOT_FILE % (cfg.EXP_NAME, cfg.TRAIN.START_EPOCH)))\n\n if rank in [-1, 0]:\n print('%s - train for %d epochs' % (cfg.EXP_NAME, cfg.TRAIN.MAX_EPOCH))\n run_train_on_data(\n model, data_reader_train, cfg, rank, gpu, run_eval=cfg.TRAIN.RUN_EVAL,\n data_reader_eval=data_reader_eval)\n if rank in [-1, 0]:\n print('%s - train (done)' % cfg.EXP_NAME)\n\n\ndef test(cfg):\n data_reader_eval, num_vocab, num_choices = load_eval_data(cfg, -1, 0)\n\n # Load model\n model = LCGNwrapper(num_vocab, num_choices, cfg)\n\n # Load test snapshot\n snapshot_file = cfg.SNAPSHOT_FILE % (cfg.EXP_NAME, cfg.TEST.EPOCH)\n model.load_state_dict(torch.load(snapshot_file))\n\n res_dir = cfg.TEST.RESULT_DIR % (cfg.EXP_NAME, cfg.TEST.EPOCH)\n vis_dir = os.path.join(\n res_dir, '%s_%s' % (cfg.TEST.VIS_DIR_PREFIX, cfg.TEST.SPLIT_VQA))\n os.makedirs(res_dir, exist_ok=True)\n os.makedirs(vis_dir, exist_ok=True)\n pred = cfg.TEST.DUMP_PRED\n if not pred:\n print('NOT writing predictions (set TEST.DUMP_PRED True to write)')\n\n print('%s - test epoch %d' % (cfg.EXP_NAME, cfg.TEST.EPOCH))\n eval_res = run_eval_on_data(cfg, model, data_reader_eval, pred=pred)\n print('%s - test epoch %d: accuracy = %.4f' % (\n cfg.EXP_NAME, cfg.TEST.EPOCH, eval_res['accuracy']))\n\n # write results\n if pred:\n dump_prediction_to_file(cfg, eval_res['predictions'], res_dir)\n eval_res.pop('predictions')\n res_file = os.path.join(res_dir, 'res_%s_%04d_%s.json' % (\n cfg.EXP_NAME, cfg.TEST.EPOCH, cfg.TEST.SPLIT_VQA))\n with open(res_file, 'w') as f:\n json.dump(eval_res, f)\n\n\nif __name__ == '__main__':\n\n cfg = build_cfg_from_argparse()\n start = time.time()\n print(f'pid: {os.getpid()} is running...')\n if cfg.train:\n if cfg.n_gpus > 1:\n os.environ['MASTER_ADDR'] = '127.0.0.1' \n os.environ['MASTER_PORT'] = '12801' \n cfg.world_size = cfg.n_gpus * cfg.nodes\n mp.spawn(train, nprocs=cfg.n_gpus, args=(cfg,))\n else:\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = cfg.GPUS\n train(-1, cfg)\n end_ = time.time()\n if cfg.DEBUG == False:\n wandb.log({\"training time\": int((end_ - start) / 60)})\n print(f'time has cost : {end_ - start}')\n else:\n test(cfg)\n"
] | [
[
"torch.cuda.manual_seed_all",
"torch.load",
"torch.multiprocessing.spawn",
"torch.manual_seed",
"torch.distributed.init_process_group",
"numpy.random.seed"
]
] |
tomelf/cnit-623 | [
"edf25f0b216b2480f7b651d3b94c1377dff721c0"
] | [
"task3_doc2vec_svm.py"
] | [
"import data_loader\nimport numpy as np\nimport pandas as pd\nimport re\nimport os.path\n\nfrom itertools import product\nfrom string import ascii_lowercase\n\nfrom sklearn.pipeline import Pipeline, FeatureUnion\nfrom sklearn.decomposition import PCA, TruncatedSVD\nfrom sklearn.metrics import roc_auc_score, accuracy_score, classification_report\nfrom sklearn.svm import SVC\nfrom sklearn.preprocessing import LabelEncoder\nfrom sklearn.feature_extraction.text import TfidfTransformer, TfidfVectorizer\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.externals import joblib\nfrom sklearn.linear_model import ElasticNet\n\ndef main():\n cols = [\"dim_{}\".format(i+1) for i in range(300)] + [\"label\"] + [\"meta_id\"]\n train_df = pd.read_csv(\"dataset/data_doc2vec_non-pretrained/train_docvec_lang_sentid.csv\", names=cols)\n dev_df = pd.read_csv(\"dataset/data_doc2vec_non-pretrained/dev_docvec_lang_sentid.csv\", names=cols)\n test_df = pd.read_csv(\"dataset/data_doc2vec_non-pretrained/test_docvec_lang_sentid.csv\", names=cols)\n \n train_actual = train_df[\"label\"].tolist()\n dev_actual = dev_df[\"label\"].tolist()\n test_actual = test_df[\"label\"].tolist()\n \n train_data_df = train_df.iloc[:,:(len(cols)-2)]\n dev_data_df = dev_df.iloc[:,:(len(cols)-2)]\n test_data_df = test_df.iloc[:,:(len(cols)-2)]\n \n print(\"Start pipeline\")\n pipeline = Pipeline([\n ('clf', SVC(decision_function_shape='ovo', C=20)),\n ])\n \n param_grid = dict(\n clf__kernel=['rbf'],\n clf__C=[0.1, 1, 10, 20])\n grid_search = GridSearchCV(pipeline, param_grid=param_grid, cv=5, verbose=10, return_train_score=True)\n \n train_pred = grid_search.fit(train_data_df, train_actual).predict(train_data_df)\n test_pred = grid_search.predict(test_data_df)\n \n with open(\"task3_test_doc2vec.txt\", \"w\") as output:\n output.write(\"Training results:\\n{}\\n\".format(classification_report(train_actual, train_pred)))\n output.write(\"Testing results:\\n{}\\n\".format(classification_report(test_actual, test_pred)))\n print(classification_report(train_actual, train_pred))\n print(classification_report(test_actual, test_pred))\n \n pd.DataFrame(grid_search.cv_results_).to_csv(\"task3_grid_search_doc2vec.csv\")\n\nif __name__ == \"__main__\":\n main()\n"
] | [
[
"sklearn.svm.SVC",
"sklearn.metrics.classification_report",
"pandas.read_csv",
"pandas.DataFrame",
"sklearn.model_selection.GridSearchCV"
]
] |
srmainwaring/python-ignition | [
"720f2e6d8e675ed7e10488caf11ef7e93e519d58"
] | [
"python/rover_publisher.py"
] | [
"#!/usr/bin/env python\n\n# Copyright (C) 2022 Rhys Mainwaring\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\nfrom scipy.spatial.transform import Rotation as Rotation\nimport math\nimport time\n\nfrom ignition.msgs.header_pb2 import Header\nfrom ignition.msgs.pose_pb2 import Pose\nfrom ignition.msgs.quaternion_pb2 import Quaternion\nfrom ignition.msgs.time_pb2 import Time\nfrom ignition.msgs.twist_pb2 import Twist\nfrom ignition.msgs.vector3d_pb2 import Vector3d\n\nfrom ignition.transport import AdvertiseMessageOptions\nfrom ignition.transport import Node\n\ndef main():\n # Create a transport node and advertise a topic\n node = Node()\n pub_options = AdvertiseMessageOptions()\n\n pose_topic = \"/pose\"\n pose_msg_type_name = Pose.DESCRIPTOR.full_name\n\n pose_pub = node.advertise(\n pose_topic, pose_msg_type_name, pub_options)\n if pose_pub.valid():\n print(\"Advertising {} on topic [{}]\".format(\n pose_msg_type_name, pose_topic))\n else:\n print(\"Error advertising topic [{}]\".format(pose_topic))\n\n twist_topic = \"/twist\"\n twist_msg_type_name = Twist.DESCRIPTOR.full_name\n twist_pub = node.advertise(\n twist_topic, twist_msg_type_name, pub_options)\n if twist_pub.valid():\n print(\"Advertising {} on topic [{}]\".format(\n twist_msg_type_name, twist_topic))\n else:\n print(\"Error advertising topic [{}]\".format(twist_topic))\n\n # rover moving in a circle of radius with constant velocity\n radius = 5.0\n ang_vel = 0.1\n\n # publish messages at 2Hz\n start = time.time_ns()\n count = 0\n try:\n while True:\n # update time\n now = time.time_ns()\n time_ns = now - start\n time_s = int(time_ns/1.0E9)\n time_ns = int(time_ns % 1000000000)\n id = count\n count += 1\n\n # update position, orientation and velocity\n wz = ang_vel\n theta = wz * time_s\n c = math.cos(theta)\n s = math.sin(theta)\n x = radius * c\n y = radius * s\n vx = -1.0 * radius * wz * s\n vy = radius * wz * c\n rot = Rotation.from_euler(\"xyz\", [0.0, 0.0, theta])\n quat = rot.as_quat()\n\n # # Prepare the messages.\n time_msg = Time()\n time_msg.sec = time_s\n time_msg.nsec = time_ns\n\n header = Header()\n header.stamp.CopyFrom(time_msg)\n\n position = Vector3d()\n position.x = x\n position.y = y\n position.z = 0.0\n\n orientation = Quaternion() \n orientation.x = quat[0]\n orientation.y = quat[1]\n orientation.z = quat[2]\n orientation.w = quat[3]\n\n pose = Pose()\n pose.name = \"base_link\"\n pose.id = id\n pose.header.CopyFrom(header)\n pose.position.CopyFrom(position)\n pose.orientation.CopyFrom(orientation)\n\n lin_vel_msg = Vector3d() \n lin_vel_msg.x = vx\n lin_vel_msg.y = vy\n lin_vel_msg.z = 0.0\n\n ang_vel_msg = Vector3d() \n ang_vel_msg.x = 0.0\n ang_vel_msg.y = 0.0\n ang_vel_msg.z = wz\n\n twist = Twist()\n twist.header.CopyFrom(header)\n twist.linear.CopyFrom(lin_vel_msg)\n twist.angular.CopyFrom(ang_vel_msg)\n\n if not pose_pub.publish(pose):\n break\n\n if not twist_pub.publish(twist):\n break\n\n print(\"Publishing pose on topic [{}], twist on topic [{}]\".format(\n pose_topic, twist_topic))\n\n time.sleep(0.5)\n\n except KeyboardInterrupt:\n pass\n\n\nif __name__ == \"__main__\":\n main()\n\n"
] | [
[
"scipy.spatial.transform.Rotation.from_euler"
]
] |
dima137/iact_dnn | [
"b0e71877cd3d6e9a1b8871dc0cbd85c16c29a84d"
] | [
"iact_dnn_utils.py"
] | [
"import numpy as np\nimport h5py\nimport time\nimport os\n\n\n# functions (to be moved to utils.py)\ndef add_meta_keys(fn, pars_keys, image_keys=[]):\n with h5py.File(fn, 'r') as f:\n for key in f.keys():\n if key not in pars_keys and key not in image_keys:\n pars_keys.append(key)\n return 0\n\n\ndef get_square_images_fn(cdict, file_number=None):\n # in the future: load the first n_events from a file with more images\n event_type = cdict['event_type']\n n_events = cdict['n_events']\n mode = cdict['mode']\n Etrue_min = cdict['Etrue_min']\n fn = '%s_%i_images_%s' % (event_type, n_events, mode)\n if Etrue_min is not None and Etrue_min != 'None':\n fn += '_Etrue_min%.1fTeV' % Etrue_min\n if cdict.get('tel') != None:\n fn += '_%s' % cdict['tel']\n if file_number is not None:\n fn += '_file%i' % file_number\n fn += '.h5'\n return fn\n\ndef get_images_fns(cdict, folder=None, exists=False, nfiles=200):\n ev_types = cdict['model_events']\n #n_events = cdict['n_events']\n #n_events_tot = cdict.get('n_events_tot', None)\n #if n_events_tot == None:\n # n_events_tot = n_events\n #nfiles = int(n_events_tot / n_events)\n out_dict = {}\n for k, event_type in enumerate(ev_types):\n cdict['event_type'] = event_type\n out_dict[event_type] = [get_square_images_fn(cdict, file_number=j+1) for j in range(nfiles)]\n if folder is not None and exists:\n out_dict[event_type] = [fn for fn in out_dict[event_type] if os.path.isfile(folder + fn)]\n return out_dict\n\ndef get_zeta_fns(cdict, folder=None, exists=False):\n out_dict = get_images_fns(cdict)\n for key in out_dict.keys():\n out_dict[key] = [fn.replace('.h5', '_zeta.h5') for fn in out_dict[key]]\n if folder is not None and exists:\n out_dict[key] = [fn for fn in out_dict[key] if os.path.isfile(folder + fn)]\n return out_dict\n\n\ndef load_images(folder, cdict):\n ev_types = cdict['model_events']\n n_events = cdict['n_events']\n n_events_tot = cdict.get('n_events_tot', None)\n if n_events_tot == None:\n n_events_tot = n_events\n nfiles = int(n_events_tot / n_events)\n data_key = cdict['data_key']\n print('load images')\n for k, event_type in enumerate(ev_types):\n print('load %s images' % event_type)\n cdict['event_type'] = event_type\n for j in range(nfiles):\n fn = folder + get_square_images_fn(cdict, file_number=j+1)\n with h5py.File(fn, 'r') as f:\n if k == 0 and j == 0:\n dims = f[data_key].shape\n out_dims = list(dims)\n out_dims[0] = n_events_tot * len(ev_types)\n images = np.zeros(out_dims, dtype=np.float32)\n ind_start = n_events_tot * k + dims[0] * j\n ind_end = n_events_tot * k + dims[0] * j + dims[0]\n fill_inds = list(range(ind_start, ind_end))\n images[fill_inds] = f[data_key][:]\n return images\n\n\ndef load_images_from_file(fn, key):\n with h5py.File(fn, 'r') as f:\n return f[key][:]\n\n\ndef get_group_key(key, f):\n for gkey in f.keys():\n if type(f[gkey]) != h5py._hl.dataset.Dataset and key in f[gkey].keys():\n return gkey\n return None\n\ndef load_meta_data(folder, cdict):\n ev_types = cdict['model_events']\n n_events = cdict['n_events']\n n_events_tot = cdict.get('n_events_tot', None)\n if n_events_tot == None:\n n_events_tot = n_events\n nfiles = int(n_events_tot / n_events)\n data_key = cdict['data_key']\n pars_keys = cdict['pars_keys']\n print('load meta data')\n for k, event_type in enumerate(ev_types):\n print(event_type)\n cdict['event_type'] = event_type\n for j in range(nfiles):\n fn = folder + get_square_images_fn(cdict, file_number=j+1)\n with h5py.File(fn, 'r') as f:\n if k == 0 and j == 0:\n pars_dict = {}\n for key in pars_keys:\n gkey = get_group_key(key, f)\n if gkey is None:\n dims = [n_events]\n out_dims = n_events_tot * len(ev_types)\n else:\n dims = f[gkey][key].shape\n out_dims = list(dims)\n out_dims[0] = n_events_tot * len(ev_types)\n pars_dict[key] = np.zeros(out_dims, dtype=np.float32)\n ind_start = n_events_tot * k + dims[0] * j\n ind_end = n_events_tot * k + dims[0] * j + dims[0]\n fill_inds = list(range(ind_start, ind_end))\n for key in pars_dict.keys():\n gkey = get_group_key(key, f)\n if key == 'CR_type':\n pars_dict[key][fill_inds] += int(event_type != 'proton')\n elif gkey is not None:\n pars_dict[key][fill_inds] = f[gkey][key][:]\n else:\n pass\n return pars_dict\n\ndef load_metadata_from_file(fn, key, event_type=None):\n with h5py.File(fn, 'r') as f:\n gkey = get_group_key(key, f)\n if key == 'CR_type' and event_type is not None:\n return int(event_type != 'proton')\n elif gkey is not None:\n return f[gkey][key][:]\n else:\n return None\n\n\n# crop images\ndef get_min_max_inds(center, half_size, nmax):\n imin = np.ceil(center - half_size)\n imax = np.ceil(center + half_size)\n shift = -imin * np.heaviside(-imin, 0.) - (imax - nmax) * np.heaviside(imax - nmax, 0.)\n imin = (imin + shift).astype(int)\n imax = (imax + shift).astype(int)\n return imin, imax, shift\n \n\ndef crop_images(images, size, test=False, crop_fraction=0.03, boundary=5):\n t0 = time.time()\n di = 0.5 * size\n nn, nx, ny = images.shape\n res_arr = np.zeros((nn, size, size))\n norm = np.sum(images, axis=(1,2)) + 1.e-15\n t1 = time.time()\n \n # center of gravity along x\n ix = np.sum(np.sum(images, axis=2) * np.arange(nx), axis=1) / norm\n ix_min, ix_max, x_shift = get_min_max_inds(ix, di, nx)\n # center of gravity along y\n iy = np.sum(np.sum(images, axis=1) * np.arange(ny), axis=1) / norm\n iy_min, iy_max, y_shift = get_min_max_inds(iy, di, ny)\n \n t2 = time.time()\n \n # if True - the image is not cropped\n #crop_mask = np.abs(x_shift) + np.abs(y_shift) == 0.\n crop_mask = np.ones(nn, dtype=bool)\n t3 = time.time()\n \n \n for i in range(nn):\n res_arr[i] = images[i, ix_min[i]:ix_max[i], iy_min[i]:iy_max[i]]\n test_image = 1. * images[i]\n in_sum = np.sum(res_arr[i])\n test_image[ix_min[i]:ix_max[i], iy_min[i]:iy_max[i]] = 0.\n out_sum = np.sum(test_image)\n if in_sum == 0. or out_sum / in_sum > crop_fraction:\n crop_mask[i] = False\n\n test_image = 1. * images[i]\n b = boundary\n in_sum = np.sum(test_image[b:-b, b:-b])\n test_image[b:-b, b:-b] = 0.\n out_sum = np.sum(test_image)\n if in_sum == 0. or out_sum / in_sum > crop_fraction:\n crop_mask[i] = False\n\n t4 = time.time()\n if test:\n print('create arrays: %.3f s' % (t1 - t0))\n print('Get indices: %.3f s' % (t2 - t1))\n print('Crop mask: %.3f s' % (t3 - t2))\n print('Create final array: %.3f s' % (t4 - t3))\n\n return res_arr, crop_mask\n\n\n\n\ndef flatten_tel_images(images):\n '''\n flatten the number of telescopes dimension of the images\n '''\n ntot, image_size, image_size, ntel = images.shape\n im_new = np.zeros((ntel*ntot, image_size, image_size), dtype=np.float32)\n for i in range(ntel):\n im_new[i::ntel] = images[:,:,:,i]\n return im_new.reshape((ntel*ntot, image_size, image_size, 1))\n\ndef deflatten_tel_images(images, ntel):\n '''\n deflatten the number of telescopes dimension of the images\n '''\n ntot, image_size, image_size = images.shape[:3]\n ntot = int(ntot / ntel)\n im_new = np.zeros((ntot, image_size, image_size, ntel), dtype=np.float32)\n for i in range(ntel):\n im_new[:,:,:,i] = images[i::ntel]\n return im_new\n\n\ndef flatten_meta_data(data, ntel=4):\n if data.ndim == 1:\n data_loc = np.outer(data, np.ones(ntel))\n else:\n data_loc = 1. * data\n return data.flatten()\n \n"
] | [
[
"numpy.ones",
"numpy.sum",
"numpy.heaviside",
"numpy.ceil",
"numpy.zeros",
"numpy.arange"
]
] |
Enopoletus/enopoletus.github.io | [
"2701900dbc0f7f4dd1ec1c78d8be14095eafad28"
] | [
"employmonth.py"
] | [
"import pandas as pd\nimport matplotlib.pyplot as plt, mpld3\nimport numpy as np\nimport scipy.signal as sp\nimport matplotlib.ticker as plticker\ndf=pd.read_csv('numbers2.csv')\ndf.columns=['DATE', 'EMPLOYEES']\ndf.DATE=pd.to_datetime(df.DATE)\ndf.EMPLOYEES=np.log(df.EMPLOYEES)\ntrend=sp.savgol_filter(df.EMPLOYEES, 707, 4)\nunsp=df.EMPLOYEES-trend\nunep=abs(unsp)\nunyp=(sp.savgol_filter(unep, 707, 6))\nuns=-(unsp)*(.5/(np.log(2)-np.log(1)))\nune=abs(uns)\nuny=(sp.savgol_filter(une, 707, 6))\nunw=uns+uny-(uns+uny).min()\nfig, ax = plt.subplots()\nplt.plot(df.DATE, unw, color='blue', lw=2)\nstart, end = ax.get_xlim()\nplt.xticks(np.arange(start, end, 1825.5))\nplt.xticks(rotation=90)\naxes = plt.gca()\naxes.set_ylim([unw.min(), unw.max()])\naxes.set_xlim([df.DATE.min(), df.DATE.max()])\nplt.savefig('foom.png', bbox_inches='tight')\n"
] | [
[
"scipy.signal.savgol_filter",
"matplotlib.pyplot.xticks",
"pandas.read_csv",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.subplots",
"numpy.arange",
"pandas.to_datetime",
"numpy.log",
"matplotlib.pyplot.plot"
]
] |
dolaameng/tensorflow_cookbook | [
"ca9bcb892239e9276e9348689e06cd6d1edd19ef"
] | [
"02_TensorFlow_Way/01_Operations_as_a_Computational_Graph/01_operations_on_a_graph.py"
] | [
"# Operations on a Computational Graph\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow.python.framework import ops\nops.reset_default_graph()\n\n# Create graph\nsess = tf.Session()\n\n# Create tensors\n\n# Create data to feed in\nx_vals = np.array([1., 3., 5., 7., 9.])\nx_data = tf.placeholder(tf.float32)\nm = tf.constant(3.)\n\n# Multiplication\nprod = tf.mul(x_data, m)\nfor x_val in x_vals:\n print(sess.run(prod, feed_dict={x_data: x_val}))\n\nmerged = tf.merge_all_summaries()\nif not os.path.exists('tensorboard_logs/'):\n os.makedirs('tensorboard_logs/')\n\nmy_writer = tf.train.SummaryWriter('tensorboard_logs/', sess.graph)\n"
] | [
[
"tensorflow.placeholder",
"tensorflow.train.SummaryWriter",
"tensorflow.python.framework.ops.reset_default_graph",
"tensorflow.mul",
"tensorflow.Session",
"numpy.array",
"tensorflow.merge_all_summaries",
"tensorflow.constant"
]
] |
glotzerlab/freud-examples | [
"589a66d7732ab1eeb097957938e766688c084ab1"
] | [
"archive/demos/afrl_helpers.py"
] | [
"import matplotlib.colors as mplColors\nimport numpy as np\nfrom bokeh.io import output_notebook\nfrom bokeh.plotting import figure\nfrom bokeh.resources import INLINE\nfrom freud import box\nfrom matplotlib import cm\n\noutput_notebook(resources=INLINE)\n\n# define vertices for hexagons\nverts = [\n [0.537284965911771, 0.31020161970069976],\n [3.7988742065678664e-17, 0.6204032394013997],\n [-0.5372849659117709, 0.31020161970070004],\n [-0.5372849659117711, -0.31020161970069976],\n [-1.1396622619703597e-16, -0.6204032394013997],\n [0.5372849659117711, -0.3102016197006997],\n]\nverts = np.array(verts)\n\n# define colors for our system\nc_list = [\n \"#30A2DA\",\n \"#FC4F30\",\n \"#E5AE38\",\n \"#6D904F\",\n \"#9757DB\",\n \"#188487\",\n \"#FF7F00\",\n \"#9A2C66\",\n \"#626DDA\",\n \"#8B8B8B\",\n]\nc_dict = dict()\nc_dict[6] = c_list[0]\nc_dict[5] = c_list[1]\nc_dict[4] = c_list[2]\nc_dict[3] = c_list[7]\nc_dict[2] = c_list[3]\nc_dict[1] = c_list[5]\nc_dict[0] = c_list[6]\nc_dict[7] = c_list[4]\n\n\nclass DemoData:\n \"\"\"docstring for DemoData\"\"\"\n\n def __init__(self, data_path):\n super().__init__()\n self.data_path = data_path\n self.verts = verts\n # load data\n self.load_data()\n\n def load_data(self):\n self.box_data = np.copy(np.load(f\"{self.data_path}/box_data.npy\"))\n self.pos_data = np.copy(np.load(f\"{self.data_path}/pos_data.npy\"))\n self.quat_data = np.copy(np.load(f\"{self.data_path}/quat_data.npy\"))\n self.n_frames = self.pos_data.shape[0]\n\n def freud_box(self, frame):\n l_box = self.box_data[frame]\n fbox = box.Box(Lx=l_box[\"Lx\"], Ly=l_box[\"Ly\"], is2D=True)\n return fbox\n\n def plot_frame(self, frame_idx, title=\"System Visualization\", linked_plot=None):\n l_box = self.box_data[frame_idx]\n l_pos = self.pos_data[frame_idx]\n l_quat = self.quat_data[frame_idx]\n l_ang = 2 * np.arctan2(np.copy(l_quat[:, 3]), np.copy(l_quat[:, 0]))\n fbox = box.Box(Lx=l_box[\"Lx\"], Ly=l_box[\"Ly\"], is2D=True)\n side_length = max(fbox.Lx, fbox.Ly)\n l_min = -side_length / 2.0\n l_min *= 1.1\n l_max = -l_min\n\n # take local vertices and rotate, translate into\n # system coordinates\n patches = local_to_global(verts, l_pos[:, 0:2], l_ang)\n\n if linked_plot is not None:\n x_range = linked_plot.x_range\n y_range = linked_plot.y_range\n else:\n x_range = (l_min, l_max)\n y_range = (l_min, l_max)\n\n # plot\n p = figure(title=title, x_range=x_range, y_range=y_range, height=300, width=300)\n p.patches(\n xs=patches[:, :, 0].tolist(),\n ys=patches[:, :, 1].tolist(),\n fill_color=(42, 126, 187),\n line_color=\"black\",\n line_width=1.5,\n ) # ,\n # legend=\"hexagons\")\n # box display\n p.patches(\n xs=[[-fbox.Lx / 2, fbox.Lx / 2, fbox.Lx / 2, -fbox.Lx / 2]],\n ys=[[-fbox.Ly / 2, -fbox.Ly / 2, fbox.Ly / 2, fbox.Ly / 2]],\n fill_color=(0, 0, 0, 0),\n line_color=\"black\",\n line_width=2,\n )\n # p.legend.location='bottom_center'\n # p.legend.orientation='horizontal'\n default_bokeh(p)\n # show(p)\n self.p = p\n return p\n\n def plot_single_neighbor(\n self,\n frame_idx,\n pidx,\n n_list,\n num_particles,\n title=\"Nearest Neighbor Visualization\",\n linked_plot=None,\n ):\n\n l_box = self.box_data[frame_idx]\n l_pos = self.pos_data[frame_idx]\n l_quat = self.quat_data[frame_idx]\n l_ang = 2 * np.arctan2(np.copy(l_quat[:, 3]), np.copy(l_quat[:, 0]))\n fbox = box.Box(Lx=l_box[\"Lx\"], Ly=l_box[\"Ly\"], is2D=True)\n side_length = max(fbox.Lx, fbox.Ly)\n l_min = -side_length / 2.0\n l_min *= 1.1\n l_max = -l_min\n\n if linked_plot is not None:\n x_range = linked_plot.x_range\n y_range = linked_plot.y_range\n else:\n x_range = (l_min, l_max)\n y_range = (l_min, l_max)\n\n n_idxs = n_list[pidx]\n # clip padded values\n n_idxs = n_idxs[np.where(n_idxs < num_particles)]\n n_neigh = len(n_idxs)\n\n # get position, orientation for the central particle\n center_pos = np.zeros(shape=(1, 3), dtype=np.float32)\n center_ang = np.zeros(shape=(1), dtype=np.float32)\n center_pos[:] = l_pos[pidx]\n center_ang[:] = l_ang[pidx]\n\n # get the positions, orientations for the neighbor particles\n neigh_pos = np.zeros(shape=(n_neigh, 3), dtype=np.float32)\n neigh_ang = np.zeros(shape=(n_neigh), dtype=np.float32)\n neigh_pos[:] = l_pos[n_idxs]\n neigh_ang[:] = l_ang[n_idxs]\n\n # render in bokeh\n # create array of transformed positions\n # all particles\n patches = local_to_global(verts, l_pos[:, 0:2], l_ang)\n # center particle\n c_patches = local_to_global(verts, center_pos[:, 0:2], center_ang)\n # neighbor particles\n n_patches = local_to_global(verts, neigh_pos[:, 0:2], neigh_ang)\n # turn into list of colors\n # bokeh (as of this version) requires hex colors, so convert rgb to hex\n center_color = np.array([c_list[0] for _ in range(center_pos.shape[0])])\n neigh_color = np.array([c_list[1] for _ in range(neigh_pos.shape[0])])\n\n # plot\n p = figure(title=title, x_range=x_range, y_range=y_range, height=300, width=300)\n p.patches(\n xs=patches[:, :, 0].tolist(),\n ys=patches[:, :, 1].tolist(),\n fill_color=(0, 0, 0, 0.1),\n line_color=\"black\",\n )\n p.patches(\n xs=n_patches[:, :, 0].tolist(),\n ys=n_patches[:, :, 1].tolist(),\n fill_color=neigh_color.tolist(),\n line_color=\"black\",\n legend=\"neighbors\",\n )\n p.patches(\n xs=c_patches[:, :, 0].tolist(),\n ys=c_patches[:, :, 1].tolist(),\n fill_color=center_color.tolist(),\n line_color=\"black\",\n legend=\"centers\",\n )\n # box display\n p.patches(\n xs=[[-fbox.Lx / 2, fbox.Lx / 2, fbox.Lx / 2, -fbox.Lx / 2]],\n ys=[[-fbox.Ly / 2, -fbox.Ly / 2, fbox.Ly / 2, fbox.Ly / 2]],\n fill_color=(0, 0, 0, 0),\n line_color=\"black\",\n line_width=2,\n )\n p.legend.location = \"bottom_center\"\n p.legend.orientation = \"horizontal\"\n default_bokeh(p)\n self.p = p\n return p\n\n def plot_neighbors(\n self,\n frame_idx,\n n_list,\n num_particles,\n n_neigh,\n title=\"Nearest Neighbor Visualization\",\n linked_plot=None,\n ):\n\n l_box = self.box_data[frame_idx]\n l_pos = self.pos_data[frame_idx]\n l_quat = self.quat_data[frame_idx]\n l_ang = 2 * np.arctan2(np.copy(l_quat[:, 3]), np.copy(l_quat[:, 0]))\n fbox = box.Box(Lx=l_box[\"Lx\"], Ly=l_box[\"Ly\"], is2D=True)\n side_length = max(fbox.Lx, fbox.Ly)\n l_min = -side_length / 2.0\n l_min *= 1.1\n l_max = -l_min\n\n if linked_plot is not None:\n x_range = linked_plot.x_range\n y_range = linked_plot.y_range\n else:\n x_range = (l_min, l_max)\n y_range = (l_min, l_max)\n\n # now for array manipulation magic\n # create an integer array of the same shape as the neighbor list array\n int_arr = np.ones(shape=n_list.shape, dtype=np.int32)\n # \"search\" for non-indexed particles (missing neighbors)\n # while it would be most accurate to use the UINTMAX value\n # provided by nn.getUINTMAX(), but this works just as well\n int_arr[n_list > (num_particles - 1)] = 0\n # sum along particle index axis to\n # determine the number of neighbors per particle\n n_neighbors = np.sum(int_arr, axis=1)\n # find the complement (if desired) to\n # find number of missing neighbors per particle\n # n_deficits = n_neigh - n_neighbors\n\n p = figure(title=title, x_range=x_range, y_range=y_range, height=300, width=300)\n for k in np.unique(n_neighbors):\n # find particles with k neighbors\n c_idxs = np.copy(np.where(n_neighbors == k)[0])\n center_pos = np.zeros(shape=(len(c_idxs), 3), dtype=np.float32)\n center_ang = np.zeros(shape=(len(c_idxs)), dtype=np.float32)\n center_pos = l_pos[c_idxs]\n center_ang = l_ang[c_idxs]\n c_patches = local_to_global(verts, center_pos[:, 0:2], center_ang)\n center_color = np.array([c_dict[k] for _ in range(center_pos.shape[0])])\n p.patches(\n xs=c_patches[:, :, 0].tolist(),\n ys=c_patches[:, :, 1].tolist(),\n fill_color=center_color.tolist(),\n line_color=\"black\",\n legend=f\"k={k}\",\n )\n p.patches(\n xs=[[-fbox.Lx / 2, fbox.Lx / 2, fbox.Lx / 2, -fbox.Lx / 2]],\n ys=[[-fbox.Ly / 2, -fbox.Ly / 2, fbox.Ly / 2, fbox.Ly / 2]],\n fill_color=(0, 0, 0, 0),\n line_color=\"black\",\n line_width=2,\n )\n p.legend.location = \"bottom_center\"\n p.legend.orientation = \"horizontal\"\n default_bokeh(p)\n self.p = p\n return p\n\n def plot_hexatic(\n self,\n frame_idx,\n psi_k,\n avg_psi_k,\n title=\"Hexatic Visualization\",\n linked_plot=None,\n ):\n\n l_box = self.box_data[frame_idx]\n l_pos = self.pos_data[frame_idx]\n l_quat = self.quat_data[frame_idx]\n l_ang = 2 * np.arctan2(np.copy(l_quat[:, 3]), np.copy(l_quat[:, 0]))\n fbox = box.Box(Lx=l_box[\"Lx\"], Ly=l_box[\"Ly\"], is2D=True)\n side_length = max(fbox.Lx, fbox.Ly)\n l_min = -side_length / 2.0\n l_min *= 1.1\n l_max = -l_min\n\n if linked_plot is not None:\n x_range = linked_plot.x_range\n y_range = linked_plot.y_range\n else:\n x_range = (l_min, l_max)\n y_range = (l_min, l_max)\n\n # create array of transformed positions\n patches = local_to_global(verts, l_pos[:, 0:2], l_ang)\n # create an array of angles relative to the average\n a = np.angle(psi_k) - np.angle(avg_psi_k)\n # turn into an rgb array of tuples\n color = [tuple(cubeellipse(x)) for x in a]\n # bokeh (as of this version) requires hex colors, so convert rgb to hex\n hex_color = [\n f\"#{clamp(r):02x}{clamp(g):02x}{clamp(b):02x}\" for (r, g, b) in color\n ]\n # plot\n p = figure(title=title, x_range=x_range, y_range=y_range, height=300, width=300)\n p.patches(\n xs=patches[:, :, 0].tolist(),\n ys=patches[:, :, 1].tolist(),\n fill_color=hex_color,\n line_color=\"black\",\n )\n default_bokeh(p)\n self.p = p\n return p\n\n def plot_orientation(\n self, frame_idx, title=\"Orientation Visualization\", linked_plot=None\n ):\n\n l_box = self.box_data[frame_idx]\n l_pos = self.pos_data[frame_idx]\n l_quat = self.quat_data[frame_idx]\n l_ang = 2 * np.arctan2(np.copy(l_quat[:, 3]), np.copy(l_quat[:, 0]))\n fbox = box.Box(Lx=l_box[\"Lx\"], Ly=l_box[\"Ly\"], is2D=True)\n side_length = max(fbox.Lx, fbox.Ly)\n l_min = -side_length / 2.0\n l_min *= 1.1\n l_max = -l_min\n\n if linked_plot is not None:\n x_range = linked_plot.x_range\n y_range = linked_plot.y_range\n else:\n x_range = (l_min, l_max)\n y_range = (l_min, l_max)\n\n # create array of transformed positions\n patches = local_to_global(verts, l_pos[:, 0:2], l_ang)\n # turn into an rgb array of tuples\n theta = l_ang * 6.0\n color = [tuple(cubeellipse(x, lam=0.5, h=2.0)) for x in theta]\n # bokeh (as of this version) requires hex colors, so convert rgb to hex\n hex_color = [\n f\"#{clamp(r):02x}{clamp(g):02x}{clamp(b):02x}\" for (r, g, b) in color\n ]\n # plot\n p = figure(title=title, x_range=x_range, y_range=y_range, height=300, width=300)\n p.patches(\n xs=patches[:, :, 0].tolist(),\n ys=patches[:, :, 1].tolist(),\n fill_color=hex_color,\n line_color=\"black\",\n )\n default_bokeh(p)\n self.p = p\n return p\n\n def plot_ld(\n self, frame_idx, ld, title=\"Local Density Visualization\", linked_plot=None\n ):\n\n l_box = self.box_data[frame_idx]\n l_pos = self.pos_data[frame_idx]\n l_quat = self.quat_data[frame_idx]\n l_ang = 2 * np.arctan2(np.copy(l_quat[:, 3]), np.copy(l_quat[:, 0]))\n fbox = box.Box(Lx=l_box[\"Lx\"], Ly=l_box[\"Ly\"], is2D=True)\n side_length = max(fbox.Lx, fbox.Ly)\n l_min = -side_length / 2.0\n l_min *= 1.1\n l_max = -l_min\n\n if linked_plot is not None:\n x_range = linked_plot.x_range\n y_range = linked_plot.y_range\n else:\n x_range = (l_min, l_max)\n y_range = (l_min, l_max)\n\n # create array of transformed positions\n patches = local_to_global(verts, l_pos[:, 0:2], l_ang)\n # create an array of angles relative to the average\n # a = np.angle(psi_k) - np.angle(avg_psi_k)\n a = ld\n # turn into an rgb array of tuples\n # handle the matplotlib colormap\n myNorm = mplColors.Normalize(vmin=0.5, vmax=0.8)\n color = [tuple(cm.RdYlBu(myNorm(x))[:3]) for x in a]\n # bokeh (as of this version) requires hex colors, so convert rgb to hex\n hex_color = [\n \"#{:02x}{:02x}{:02x}\".format(\n clamp(int(255 * r)), clamp(int(255 * g)), clamp(int(255 * b))\n )\n for (r, g, b) in color\n ]\n # plot\n p = figure(title=title, x_range=x_range, y_range=y_range, height=300, width=300)\n p.patches(\n xs=patches[:, :, 0].tolist(),\n ys=patches[:, :, 1].tolist(),\n fill_color=hex_color,\n line_color=\"black\",\n )\n default_bokeh(p)\n self.p = p\n return p\n\n\ndef default_bokeh(p):\n \"\"\"\n wrapper which takes the default bokeh outputs and changes them to more sensible values\n \"\"\"\n p.title.text_font_size = \"18pt\"\n p.title.align = \"center\"\n\n p.xaxis.axis_label_text_font_size = \"14pt\"\n p.yaxis.axis_label_text_font_size = \"14pt\"\n\n p.xaxis.major_tick_in = 10\n p.xaxis.major_tick_out = 0\n p.xaxis.minor_tick_in = 5\n p.xaxis.minor_tick_out = 0\n\n p.yaxis.major_tick_in = 10\n p.yaxis.major_tick_out = 0\n p.yaxis.minor_tick_in = 5\n p.yaxis.minor_tick_out = 0\n\n p.xaxis.major_label_text_font_size = \"12pt\"\n p.yaxis.major_label_text_font_size = \"12pt\"\n\n\ndef cubeellipse(theta, lam=0.6, gamma=1.0, s=4.0, r=1.0, h=1.2):\n \"\"\"Create an RGB colormap from an input angle theta. Takes lam (a list of\n intensity values, from 0 to 1), gamma (a nonlinear weighting power),\n s (starting angle), r (number of revolutions around the circle), and\n h (a hue factor).\"\"\"\n import numpy\n\n lam = lam ** gamma\n\n a = h * lam * (1 - lam) * 0.5\n v = numpy.array(\n [[-0.14861, 1.78277], [-0.29227, -0.90649], [1.97294, 0.0]], dtype=numpy.float32\n )\n ctarray = numpy.array(\n [numpy.cos(theta * r + s), numpy.sin(theta * r + s)], dtype=numpy.float32\n )\n # convert to 255 rgb\n ctarray = (lam + a * v.dot(ctarray)).T\n ctarray *= 255\n ctarray = ctarray.astype(dtype=np.int32)\n return ctarray\n\n\ndef local_to_global(verts, positions, orientations):\n \"\"\"\n Take a list of vertices, positions, and orientations and create\n a list of vertices in the \"global coordinate system\" for plotting\n in bokeh\n \"\"\"\n num_particles = len(positions)\n num_verts = len(verts)\n # create list of vertices in the \"local reference frame\" i.e.\n # centered at (0,0)\n l_verts = np.zeros(shape=(num_particles, num_verts, 2), dtype=np.float32)\n l_verts[:] = verts\n # create array of rotation matrices\n rot_mat = np.zeros(shape=(num_particles, 2, 2), dtype=np.float32)\n for i, theta in enumerate(orientations):\n rot_mat[i] = [[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]\n # rotate; uses einsum for speed; please see numpy documentation\n # for more information\n r_verts = np.einsum(\"lij,lkj->lki\", rot_mat, l_verts)\n # now translate to global coordinates\n # need to create a position array with same shape as vertex array\n l_pos = np.zeros(shape=(num_particles, num_verts, 2), dtype=np.float32)\n for i in range(num_particles):\n for j in range(len(verts)):\n l_pos[i, j] = positions[i]\n # translate\n output_array = np.add(r_verts, l_pos)\n return output_array\n\n\ndef clamp(x):\n \"\"\"\n limit values between 0 and 255\n http://stackoverflow.com/questions/3380726/converting-a-rgb-color-tuple-to-a-six-digit-code-in-python\n \"\"\"\n return max(0, min(x, 255))\n\n\ndef demo1(l_box, l_pos, l_ang, verts, title=\"System Visualization\"):\n # create box\n fbox = box.Box(Lx=l_box[\"Lx\"], Ly=l_box[\"Ly\"], is2D=True)\n side_length = max(fbox.Lx, fbox.Ly)\n l_min = -side_length / 2.0\n l_min *= 1.1\n l_max = -l_min\n\n # take local vertices and rotate, translate into\n # system coordinates\n patches = local_to_global(verts, l_pos[:, 0:2], l_ang)\n\n # plot\n p = figure(\n title=title,\n x_range=(l_min, l_max),\n y_range=(l_min, l_max),\n height=300,\n width=300,\n )\n p.patches(\n xs=patches[:, :, 0].tolist(),\n ys=patches[:, :, 1].tolist(),\n fill_color=(42, 126, 187),\n line_color=\"black\",\n line_width=1.5,\n ) # ,\n # legend=\"hexagons\")\n # box display\n p.patches(\n xs=[[-fbox.Lx / 2, fbox.Lx / 2, fbox.Lx / 2, -fbox.Lx / 2]],\n ys=[[-fbox.Ly / 2, -fbox.Ly / 2, fbox.Ly / 2, fbox.Ly / 2]],\n fill_color=(0, 0, 0, 0),\n line_color=\"black\",\n line_width=2,\n )\n # p.legend.location='bottom_center'\n # p.legend.orientation='horizontal'\n default_bokeh(p)\n # show(p)\n return p\n"
] | [
[
"numpy.ones",
"numpy.sum",
"numpy.load",
"numpy.zeros",
"numpy.einsum",
"matplotlib.colors.Normalize",
"numpy.cos",
"numpy.copy",
"numpy.add",
"numpy.angle",
"numpy.array",
"numpy.sin",
"numpy.where",
"numpy.unique"
]
] |
umutcanceyhan7/python_survival_game | [
"43437c14be5e96817f96e4571000197acf5d90ac"
] | [
"ceng113_hw5_260201003.py"
] | [
"# Umutcan CEYHAN 260201003 \nimport numpy\n\nclass Game():\n def __init__(self,map_width,map_height,init_time, action_cost):\n # The Game initializes map parameters.\n self.mapwidth = map_width\n self.mapheight = map_height\n # The Game initializes its map with all empty squares.\n self.map = [['empty' for col in range(map_width)] for row in range(map_height)]\n # The Game creates its player object.\n self.player = Player()\n # The Game creates its time object.\n self.time = Time(0,init_time, action_cost)\n # The Game initializes the player icon.\n self.picon = person\n # The Game sets the continue state to true (still has time)\n self.cont = True\n # The Game sets the safe state to false (still not in shelter)\n self.safe = False\n # The Game initializes the list of squares that constitutes the shelter \n self.score_map = []\n # The Game randomly inserts wood, dirt or water on the map.\n self.generate_map()\n # The Game prints the current status on the screen.\n self.update_screen()\n\n # For each square, put wood with probability of 0.3, put dirt with probability of 0.3,\n # put water with probability of 0.2 or leave empty with probability of 0.2. You have\n # to use 'numpy.random.randint' function. \n def generate_map(self):\n for row in range(self.mapheight):\n for col in range(self.mapwidth):\n square = numpy.random.randint(0, 11)\n if( 1 >= square <= 3):\n self.map[row][col] = \"wood \"\n elif( 4 >= square <= 6):\n self.map[row][col] = \"dirt \"\n elif( 7 >= square <= 8):\n self.map[row][col] = \"water\"\n else:\n self.map[row][col] = \"empty\"\n \n def show_controls(self): \n print()\n print(\"**************************** Game Control ****************************\")\n print(\"w: up s: down a: left d: rigth\")\n print(\"1: put brick 2: put dirt 3: put plank 4: put water 5: put wood\")\n print(\"q: pick e: make plank r: make brick o: exit game\")\n print(\"plank: 2 woods brick: 2 dirt 1 water\")\n print(\"plank: 2 pts brick: 3 pts enclosed square: 3 pts\")\n print(\"**********************************************************************\")\n print()\n def show_map(self):\n ppy = self.player.pos[0]\n ppx = self.player.pos[1]\n print()\n for row in range(MAP_HEIGHT):\n color_row = [COLORS[self.map[row][c]] for c in range(MAP_WIDTH)]\n if row == ppy:\n color_row[ppx] = color_row[ppx].replace(' ',' '+self.picon+' ')\n print(''.join(color_row)) \n def update_screen(self):\n self.player.show_inventory()\n self.time.show_time()\n self.show_map()\n self.show_controls()\n def _flood_fill(self,wmf,ppx,ppy,source,target,conn8=True):\n if wmf[ppy,ppx]!=source:\n return\n wmf[ppy,ppx] = target\n if ppy>0: self._flood_fill(wmf,ppx,ppy-1,source,target,conn8)\n if ppy<wmf.shape[0]-1: self._flood_fill(wmf,ppx,ppy+1,source,target,conn8)\n if ppx>0: self._flood_fill(wmf,ppx-1,ppy,source,target,conn8)\n if ppx<wmf.shape[1]-1: self._flood_fill(wmf,ppx+1,ppy,source,target,conn8)\n if conn8:\n if ppy>0 and ppx>0: self._flood_fill(wmf,ppx-1,ppy-1,source,target,conn8)\n if ppy>0 and ppx<wmf.shape[1]-1: self._flood_fill(wmf,ppx+1,ppy-1,source,target,conn8)\n if ppy<wmf.shape[0]-1 and ppx>0: self._flood_fill(wmf,ppx-1,ppy+1,source,target),conn8\n if ppy<wmf.shape[0]-1 and ppx<wmf.shape[1]-1: self._flood_fill(wmf,ppx+1,ppy+1,source,target,conn8)\n def check_safety(self):\n # This function checks if the player is in a shelter. It should be called\n # at the end of each successfully executed action to check if the game \n # has finished.\n wall_map = numpy.zeros((game.mapwidth+2,game.mapheight+2)).astype(int)\n wall_map_bool = [numpy.in1d(row, ['brick','plank']) for row in game.map]\n wall_map[1:-1,1:-1] = numpy.array(wall_map_bool).astype(int)\n label = 2\n while((wall_map == 1).any()):\n py = numpy.where(wall_map==1)[0][0]\n px = numpy.where(wall_map==1)[1][0]\n self._flood_fill(wall_map, px, py, 1, label, False)\n label += 1\n ppx = game.player.pos[1]+1\n ppy = game.player.pos[0]+1\n if not wall_map[ppy,ppx]:\n for wall in range(2,label):\n wall_map_fill = (wall_map == wall).astype(int) \n self._flood_fill(wall_map_fill,ppx,ppy,0,label)\n edges = [wall_map_fill[0,:],wall_map_fill[-1,:], wall_map_fill[:,0],wall_map_fill[:,-1]]\n if label not in numpy.array(edges):\n self.safe = True\n self.score_map = wall_map_fill[1:-1,1:-1]\n self.picon = happy\n break\n def calc_score(self):\n final_map = (numpy.array(self.map) == 'brick').astype(int) + self.score_map\n unique, counts = numpy.unique(final_map, return_counts=True)\n score = counts[-1]*3 + counts[-2]*3 + counts[-3]*2 #area*3+brick*3+plank*2\n return score\n def move_player(self,direction):\n self.player.move(direction)\n self.update_screen()\n # Pick item using the player object's pick method and update the map if \n # there is an item to pick, otherwise print \"There is nothing to pick!\". \n def pick_item(self):\n ppx = self.player.pos[0] #Row\n ppy = self.player.pos[1] #Column\n if (self.map[ppx][ppy] == \"empty\"):\n print(\"There is nothing to pick!\")\n else:\n self.player.pick(self.map[ppx][ppy]) #Picks the item where it is\n self.map[ppx][ppy] = \"empty\"\n self.update_screen()\n # Put the given item using the player object's put method if the current\n # square is empty, otherwise print \"\"There is nowhere to put!\". If the\n # player scan successfully put the item, update the map. \n def put_item(self,item):\n ppx = self.player.pos[0]\n ppy = self.player.pos[1]\n if(self.map[ppx][ppy] == \"empty\"):\n self.player.put(item)\n self.update_screen()\n else:\n print(\"There is nowhere to put!\")\n \n # Make the given item using the player object's corresponding method. If\n # the player can not make the item, print \"Not enough material!\".\n def make(self,item):\n if(item == \"e\"):\n if(self.player.make_plank()):\n self.update_screen()\n else:\n print(\"Not enough material!\")\n else:\n if(self.player.make_brick()):\n self.update_screen()\n else:\n print(\"Not enough material!\")\n \n \n\nclass Player():\n def __init__(self):\n # Initialize the player position at the top left corner\n self.pos = [0,0]\n # Initialize the inventory as empty\n self.inventory = {'wood ':0,'dirt ':0,'water':0,'plank':0,'brick':0}\n def move(self, direction):\n # Update the player position with respect to move direction.\n if(direction == \"w\" ):\n if not(self.pos[0] == 0):\n self.pos[0] -= 1\n game.time.spend()\n else:\n print(\"Sorry I can not move up\")\n elif(direction == \"s\"):\n if not(self.pos[0] == MAP_HEIGHT-1):\n self.pos[0] += 1 \n game.time.spend()\n else:\n print(\"Sorry I can not move down\")\n elif(direction == \"a\"):\n if not(self.pos[1] == 0):\n self.pos[1] -= 1\n game.time.spend()\n else:\n print(\"Sorry I can not move left\")\n else:\n if not(self.pos[1] == MAP_WIDTH-1):\n self.pos[1] += 1\n game.time.spend()\n else:\n print(\"Sorry I can not move right\")\n return self.pos\n \n # Pick and update the player inventory with respect to the item.\n def pick(self, item):\n if(item == \"brick\"):\n self.inventory[\"brick\"] += 1 \n game.time.spend()\n elif(item == \"dirt \"):\n self.inventory[\"dirt \"] += 1\n game.time.spend()\n elif(item == \"plank\"):\n self.inventory[\"plank\"] += 1\n game.time.spend()\n elif(item == \"water\"):\n self.inventory[\"water\"] += 1\n game.time.spend()\n elif(item == \"wood \"):\n self.inventory[\"wood \"] += 1\n game.time.spend()\n \n # Put and update the player inventory with respect to the item, if the\n # player has one or more of that item in the inventory. Return true if\n # successfully put, otherwise false.\n def put(self,item):\n ppx = game.player.pos[0] #Row\n ppy = game.player.pos[1] #Column\n if(item == \"1\"):\n if(self.inventory[\"brick\"] >= 1):\n self.inventory[\"brick\"] -= 1\n game.map[ppx][ppy] = \"brick\"\n game.time.spend()\n return True\n else:\n print(\"There is nothing to put!\")\n return False \n elif(item == \"2\"):\n if(self.inventory[\"dirt \"] >= 1):\n self.inventory[\"dirt \"] -= 1\n game.map[ppx][ppy] = \"dirt \"\n game.time.spend()\n return True\n else:\n print(\"There is nothing to put!\")\n return False\n elif(item == \"3\"):\n if(self.inventory[\"plank\"] >= 1):\n self.inventory[\"plank\"] -= 1\n game.map[ppx][ppy] = \"plank\"\n game.time.spend()\n return True\n else:\n print(\"There is nothing to put!\")\n return False\n elif(item == \"4\"):\n if(self.inventory[\"water\"] >= 1):\n self.inventory[\"water\"] -= 1\n game.map[ppx][ppy] = \"water\" \n game.time.spend()\n return True\n else:\n print(\"There is nothing to put!\")\n return False\n else:\n if(self.inventory[\"wood \"] >= 1):\n self.inventory[\"wood \"] -= 1\n game.map[ppx][ppy] = \"wood \"\n game.time.spend()\n return True\n else:\n print(\"There is nothing to put!\")\n return False\n # Make plank and update the player inventory with respect to the action,\n # if the player has enough materials. Return true if plank is successfully \n # made, otherwise false. \n def make_plank(self):\n if(self.inventory[\"wood \"] >= 2):\n self.inventory[\"wood \"] -= 2 \n self.inventory[\"plank\"] += 1\n game.time.spend()\n return True\n return False\n # Make brick and update the player inventory with respect to the action,\n # if the player has enough materials. Return true if brick is successfully \n # made, otherwise false.\n def make_brick(self):\n if(self.inventory[\"dirt \"] >= 2 and self.inventory[\"water\"] >= 1):\n self.inventory[\"dirt \"] -= 2 \n self.inventory[\"water\"] -= 1 \n self.inventory[\"brick\"] += 1\n game.time.spend()\n return True\n return False\n \n # Shows the player inventory\n def show_inventory(self):\n print()\n c = 1\n for key in sorted(self.inventory.keys()):\n print(\"{}. {}\\t: {}\".format(c, key, (COLORS[key]+\" \")*self.inventory[key]))\n c += 1\n print() \n\nclass Time():\n def __init__(self, mins, hours, action_cost):\n self.mins = mins\n self.hours = hours\n self.action_cost = action_cost\n # Spend the action cost and update mins and/or hours. If the time is\n # up return False, otherwise True.\n def spend(self):\n if(self.hours > 0 and self.mins == 0):\n self.mins = 60\n self.mins -= self.action_cost\n self.hours -= 1\n return True\n else:\n self.mins -= self.action_cost\n if(self.hours == 0 and self.mins == 0):\n game.cont = False\n return False\n return True\n\n # Shows the remaning time in hours and mins format\n def show_time(self):\n print(\"{} hours {} minutes left!!!\".format(self.hours, self.mins))\n\n# CONSTANTS \nMAP_WIDTH = 10\nMAP_HEIGHT = 10\nACTION_COST = 15 #minutes\nINIT_TIME = 16 #hours\nperson =u\"\\u2687\" #character #u'U' #u'\\u267f' #u'\\u2687' \nhappy = u\"\\u263b\" # happy character\nCOLORS = {'empty':'\\033[40m \\033[0m', 'wood ':'\\033[42m \\033[0m',\n 'dirt ':'\\033[47m \\033[0m', 'water':'\\033[46m \\033[0m',\n 'plank':'\\033[43m \\033[0m', 'brick':'\\033[41m \\033[0m'}\n \n# Constant moves, items and products \nmoves = {\"w\":\"up\", \"s\":\"down\", \"a\":\"left\", \"d\":\"right\"}\nitems = {\"1\":\"brick\", \"2\":\"dirt \", \"3\":\"plank\", \"4\":\"water\", \"5\":\"wood \"}\nproducts = {\"e\":\"plank\", \"r\":\"brick\"}\n\n# A Game class is instantiated each time a new game begins.\n\n\ngame = Game(MAP_WIDTH, MAP_HEIGHT, INIT_TIME, ACTION_COST)\nout = False\n\n################## THIS PART CAUSES AN INFINITE LOOP!!! ##################\n# Implement the game play. Take the instructions from the user and execute them.\nwhile game.cont and not game.safe:\n instructions = input(\"Make your move : \")\n if(instructions == \"o\"):\n game.cont = False\n out = True\n elif(instructions == \"a\" or instructions == \"w\" or instructions == \"d\" or instructions == \"s\" ):\n game.move_player(instructions)\n elif(instructions == \"q\"):\n game.pick_item()\n elif(instructions == \"1\" or instructions == \"2\" or instructions == \"3\" or instructions == \"4\" or instructions == \"5\"):\n game.put_item(instructions)\n elif(instructions == \"e\" or instructions == \"r\"):\n game.make(instructions)\n game.check_safety()\n \nif game.safe:\n print(\"Congratulations! You are safe!!!\")\n print(\"Your score is {}.\".format(game.calc_score()))\nelif out:\n print(\"Bye!\")\nelse:\n print(\"Too late! They are coming!!!\") \n"
] | [
[
"numpy.zeros",
"numpy.in1d",
"numpy.array",
"numpy.where",
"numpy.random.randint",
"numpy.unique"
]
] |
shaoliangliang1996/pyBKT | [
"1354f95d7db6dd217c1a58cabc9c1352141ad4fd"
] | [
"source-py/pyBKT/util/metrics.py"
] | [
"import numpy as np\nimport sklearn.metrics as sk\n\nSUPPORTED_METRICS = ['accuracy', 'auc', 'rmse']\n\ndef error_check(flat_true_values, pred_values):\n if len(flat_true_values) != len(pred_values):\n raise ValueError(\"preds and true values need to have same shape\")\n\ndef accuracy(flat_true_values, pred_values):\n error_check(flat_true_values, pred_values)\n if len(flat_true_values) == 0:\n return np.nan\n correct = 0\n for i in range(len(pred_values)):\n if pred_values[i] >= 0.5 and flat_true_values[i] == 1:\n correct += 1\n if pred_values[i] < 0.5 and flat_true_values[i] == 0:\n correct += 1\n return correct/len([x for x in flat_true_values if (x == 0 or x == 1)])\n\ndef auc(flat_true_values, pred_values):\n error_check(flat_true_values, pred_values)\n # multiprior handling, remove phantom nondata\n if len(flat_true_values) == 0:\n return np.nan\n i = 0\n while i < len(flat_true_values):\n if (flat_true_values[i] != 1 and flat_true_values[i] != 0) or (pred_values[i] < 0 or pred_values[i] > 1):\n flat_true_values = np.delete(flat_true_values, i)\n pred_values = np.delete(pred_values, i)\n i -= 1\n i += 1\n if len(set(flat_true_values)) == 1:\n return np.nan\n\n auc = sk.roc_auc_score(flat_true_values, pred_values)\n return auc\n\ndef rmse(flat_true_values, pred_values):\n # represent correct as 1, incorrect as 0 for RMSE calculation\n if len(flat_true_values) == 0:\n return np.nan\n error_check(flat_true_values, pred_values)\n rmse, c = 0, 0\n for i in range(len(flat_true_values)):\n if flat_true_values[i] != -1:\n rmse += ((flat_true_values[i] - pred_values[i]) ** 2)\n c += 1\n rmse /= c\n rmse = rmse ** 0.5\n return rmse\n\n"
] | [
[
"sklearn.metrics.roc_auc_score",
"numpy.delete"
]
] |
tasbolat1/DGflow | [
"6ce22095a0d33f4da3c15f093aa365ba6cabbac9"
] | [
"conditional_batchnorm.py"
] | [
"import torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.nn import init\n\n\nclass ConditionalBatchNorm2d(nn.BatchNorm2d):\n\n \"\"\"Conditional Batch Normalization\"\"\"\n\n def __init__(self, num_features, eps=1e-05, momentum=0.1,\n affine=False, track_running_stats=True):\n super(ConditionalBatchNorm2d, self).__init__(\n num_features, eps, momentum, affine, track_running_stats\n )\n\n def forward(self, input, weight, bias, **kwargs):\n self._check_input_dim(input)\n\n exponential_average_factor = 0.0\n\n if self.training and self.track_running_stats:\n self.num_batches_tracked += 1\n if self.momentum is None: # use cumulative moving average\n exponential_average_factor = 1.0 /\\\n self.num_batches_tracked.item()\n else: # use exponential moving average\n exponential_average_factor = self.momentum\n\n output = F.batch_norm(input, self.running_mean, self.running_var,\n self.weight, self.bias,\n self.training or not self.track_running_stats,\n exponential_average_factor, self.eps)\n if weight.dim() == 1:\n weight = weight.unsqueeze(0)\n if bias.dim() == 1:\n bias = bias.unsqueeze(0)\n size = output.size()\n weight = weight.unsqueeze(-1).unsqueeze(-1).expand(size)\n bias = bias.unsqueeze(-1).unsqueeze(-1).expand(size)\n return weight * output + bias\n\n\nclass CategoricalConditionalBatchNorm2d(ConditionalBatchNorm2d):\n\n def __init__(self, num_classes, num_features, eps=1e-5, momentum=0.1,\n affine=False, track_running_stats=True):\n super(CategoricalConditionalBatchNorm2d, self).__init__(\n num_features, eps, momentum, affine, track_running_stats\n )\n self.weights = nn.Embedding(num_classes, num_features)\n self.biases = nn.Embedding(num_classes, num_features)\n\n self._initialize()\n\n def _initialize(self):\n init.ones_(self.weights.weight.data)\n init.zeros_(self.biases.weight.data)\n\n def forward(self, input, c, **kwargs):\n weight = self.weights(c)\n bias = self.biases(c)\n\n return super(CategoricalConditionalBatchNorm2d, self)\\\n .forward(input, weight, bias)\n\n\nif __name__ == '__main__':\n \"\"\"Forward computation check.\"\"\"\n import torch\n size = (3, 3, 12, 12)\n batch_size, num_features = size[:2]\n print('# Affirm embedding output')\n naive_bn = nn.BatchNorm2d(3)\n idx_input = torch.tensor([1, 2, 0], dtype=torch.long)\n embedding = nn.Embedding(3, 3)\n weights = embedding(idx_input)\n print('# weights size', weights.size())\n empty = torch.tensor((), dtype=torch.float)\n running_mean = empty.new_zeros((3,))\n running_var = empty.new_ones((3,))\n\n naive_bn_W = naive_bn.weight\n\n input = torch.rand(*size, dtype=torch.float32)\n print('input size', input.size())\n print('input ndim ', input.dim())\n\n _ = naive_bn(input)\n\n print('# batch_norm with given weights')\n\n try:\n with torch.no_grad():\n output = F.batch_norm(input, running_mean, running_var,\n weights, naive_bn.bias, False, 0.0, 1e-05)\n except Exception as e:\n print(\"\\tFailed to use given weights\")\n print('# Error msg:', e)\n print()\n else:\n print(\"Succeeded to use given weights\")\n\n print('\\n# Batch norm before use given weights')\n with torch.no_grad():\n tmp_out = F.batch_norm(input, running_mean, running_var,\n naive_bn_W, naive_bn.bias, False, .0, 1e-05)\n weights_cast = weights.unsqueeze(-1).unsqueeze(-1)\n weights_cast = weights_cast.expand(tmp_out.size())\n try:\n out = weights_cast * tmp_out\n except Exception:\n print(\"Failed\")\n else:\n print(\"Succeeded!\")\n print('\\t {}'.format(out.size()))\n print(type(tuple(out.size())))\n\n print('--- condBN and catCondBN ---')\n\n catCondBN = CategoricalConditionalBatchNorm2d(3, 3)\n output = catCondBN(input, idx_input)\n\n assert tuple(output.size()) == size\n\n condBN = ConditionalBatchNorm2d(3)\n\n idx = torch.tensor([1], dtype=torch.long)\n out = catCondBN(input, idx)\n\n print('cat cond BN weights\\n', catCondBN.weights.weight.data)\n print('cat cond BN biases\\n', catCondBN.biases.weight.data)\n"
] | [
[
"torch.nn.BatchNorm2d",
"torch.rand",
"torch.no_grad",
"torch.tensor",
"torch.nn.Embedding",
"torch.nn.functional.batch_norm",
"torch.nn.init.ones_",
"torch.nn.init.zeros_"
]
] |
timothymillar/sgkit | [
"a3a5e961b6b21ff7de235075955c0f797ad5027c"
] | [
"sgkit/model.py"
] | [
"from typing import Any, Dict, Hashable, List, Optional\n\nimport numpy as np\nimport xarray as xr\n\nfrom .typing import ArrayLike\nfrom .utils import create_dataset\n\nDIM_VARIANT = \"variants\"\nDIM_SAMPLE = \"samples\"\nDIM_PLOIDY = \"ploidy\"\nDIM_ALLELE = \"alleles\"\nDIM_GENOTYPE = \"genotypes\"\n\n\ndef create_genotype_call_dataset(\n *,\n variant_contig_names: List[str],\n variant_contig: ArrayLike,\n variant_position: ArrayLike,\n variant_allele: ArrayLike,\n sample_id: ArrayLike,\n call_genotype: ArrayLike,\n call_genotype_phased: Optional[ArrayLike] = None,\n variant_id: Optional[ArrayLike] = None,\n mixed_ploidy: bool = False,\n) -> xr.Dataset:\n \"\"\"Create a dataset of genotype calls.\n\n Parameters\n ----------\n variant_contig_names\n The contig names.\n variant_contig\n [array_like, element type: int]\n The (index of the) contig for each variant.\n variant_position\n [array_like, element type: int]\n The reference position of the variant.\n variant_allele\n [array_like, element_type: zero-terminated bytes, e.g. \"S1\", or object]\n The possible alleles for the variant.\n sample_id\n [array_like, element type: str or object]\n The unique identifier of the sample.\n call_genotype\n [array_like, element type: int] Genotype, encoded as allele values\n (0 for the reference, 1 for the first allele, 2 for the second allele),\n or -1 to indicate a missing value.\n call_genotype_phased\n [array_like, element type: bool, optional] A flag for each call indicating if it is\n phased or not. If omitted all calls are unphased.\n variant_id\n [array_like, element type: str or object, optional]\n The unique identifier of the variant.\n mixed_ploidy\n Specify if the dataset contains genotype calls with a mixture of ploidy levels\n using the value -2 to indicate non-alleles.\n\n Returns\n -------\n The dataset of genotype calls.\n \"\"\"\n data_vars: Dict[Hashable, Any] = {\n \"variant_contig\": ([DIM_VARIANT], variant_contig),\n \"variant_position\": ([DIM_VARIANT], variant_position),\n \"variant_allele\": ([DIM_VARIANT, DIM_ALLELE], variant_allele),\n \"sample_id\": ([DIM_SAMPLE], sample_id),\n \"call_genotype\": (\n [DIM_VARIANT, DIM_SAMPLE, DIM_PLOIDY],\n call_genotype,\n {\"mixed_ploidy\": mixed_ploidy},\n ),\n \"call_genotype_mask\": (\n [DIM_VARIANT, DIM_SAMPLE, DIM_PLOIDY],\n call_genotype < 0,\n ),\n }\n if call_genotype_phased is not None:\n data_vars[\"call_genotype_phased\"] = (\n [DIM_VARIANT, DIM_SAMPLE],\n call_genotype_phased,\n )\n if mixed_ploidy is True:\n data_vars[\"call_genotype_non_allele\"] = (\n [DIM_VARIANT, DIM_SAMPLE, DIM_PLOIDY],\n call_genotype < -1,\n )\n if variant_id is not None:\n data_vars[\"variant_id\"] = ([DIM_VARIANT], variant_id)\n attrs: Dict[Hashable, Any] = {\"contigs\": variant_contig_names}\n return create_dataset(data_vars=data_vars, attrs=attrs)\n\n\ndef create_genotype_dosage_dataset(\n *,\n variant_contig_names: List[str],\n variant_contig: ArrayLike,\n variant_position: ArrayLike,\n variant_allele: ArrayLike,\n sample_id: ArrayLike,\n call_dosage: ArrayLike,\n call_genotype_probability: ArrayLike,\n variant_id: Optional[ArrayLike] = None,\n) -> xr.Dataset:\n \"\"\"Create a dataset of genotype dosages.\n\n Parameters\n ----------\n variant_contig_names\n The contig names.\n variant_contig\n [array_like, element type: int]\n The (index of the) contig for each variant.\n variant_position\n [array_like, element type: int]\n The reference position of the variant.\n variant_allele\n [array_like, element_type: zero-terminated bytes, e.g. \"S1\", or object]\n The possible alleles for the variant.\n sample_id\n [array_like, element type: str or object]\n The unique identifier of the sample.\n call_dosage\n [array_like, element type: float]\n Dosages, encoded as floats, with NaN indicating a\n missing value.\n call_genotype_probability\n [array_like, element type: float]\n Probabilities, encoded as floats, with NaN indicating a\n missing value.\n variant_id\n [array_like, element type: str or object, optional]\n The unique identifier of the variant.\n\n Returns\n -------\n The dataset of genotype calls.\n\n \"\"\"\n data_vars: Dict[Hashable, Any] = {\n \"variant_contig\": ([DIM_VARIANT], variant_contig),\n \"variant_position\": ([DIM_VARIANT], variant_position),\n \"variant_allele\": ([DIM_VARIANT, DIM_ALLELE], variant_allele),\n \"sample_id\": ([DIM_SAMPLE], sample_id),\n \"call_dosage\": ([DIM_VARIANT, DIM_SAMPLE], call_dosage),\n \"call_dosage_mask\": ([DIM_VARIANT, DIM_SAMPLE], np.isnan(call_dosage)),\n \"call_genotype_probability\": (\n [DIM_VARIANT, DIM_SAMPLE, DIM_GENOTYPE],\n call_genotype_probability,\n ),\n \"call_genotype_probability_mask\": (\n [DIM_VARIANT, DIM_SAMPLE, DIM_GENOTYPE],\n np.isnan(call_genotype_probability),\n ),\n }\n if variant_id is not None:\n data_vars[\"variant_id\"] = ([DIM_VARIANT], variant_id)\n attrs: Dict[Hashable, Any] = {\"contigs\": variant_contig_names}\n return create_dataset(data_vars=data_vars, attrs=attrs)\n"
] | [
[
"numpy.isnan"
]
] |
fperez/nipy | [
"559f17150bd9fa8ead4fd088b330d7cf7db7aa79"
] | [
"nipy/io/tests/test_save.py"
] | [
"# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-\n# vi: set ft=python sts=4 ts=4 sw=4 et:\nimport os\nfrom tempfile import mkstemp\nimport numpy as np\n\nfrom nipy.testing import assert_true, assert_false, assert_equal, \\\n assert_array_almost_equal, funcfile\n\n\nfrom nipy.io.api import load_image, save_image\nfrom nipy.core import api\n\nclass Tempfile():\n file = None\n\ntmpfile = Tempfile()\n\ndef setup():\n fd, tmpfile.name = mkstemp(suffix='.nii')\n tmpfile.file = open(tmpfile.name)\n\ndef teardown():\n tmpfile.file.close()\n os.unlink(tmpfile.name)\n\n\ndef test_save1():\n # A test to ensure that when a file is saved, the affine and the\n # data agree. This image comes from a NIFTI file\n\n img = load_image(funcfile)\n save_image(img, tmpfile.name)\n img2 = load_image(tmpfile.name)\n yield assert_true, np.allclose(img.affine, img2.affine)\n yield assert_equal, img.shape, img2.shape\n yield assert_true, np.allclose(np.asarray(img2), np.asarray(img))\n\n\ndef test_save2():\n # A test to ensure that when a file is saved, the affine and the\n # data agree. This image comes from a NIFTI file \n\n shape = (13,5,7,3)\n step = np.array([3.45,2.3,4.5,6.93])\n\n cmap = api.AffineTransform.from_start_step('ijkt', 'xyzt', [1,3,5,0], step)\n\n data = np.random.standard_normal(shape)\n img = api.Image(data, cmap)\n save_image(img, tmpfile.name)\n img2 = load_image(tmpfile.name)\n yield assert_true, np.allclose(img.affine, img2.affine)\n yield assert_equal, img.shape, img2.shape\n yield assert_true, np.allclose(np.asarray(img2), np.asarray(img))\n\n\ndef test_save2b():\n # A test to ensure that when a file is saved, the affine and the\n # data agree. This image comes from a NIFTI file This example has\n # a non-diagonal affine matrix for the spatial part, but is\n # 'diagonal' for the space part. this should raise a warnings\n # about 'non-diagonal' affine matrix\n\n # make a 5x5 transformatio\n step = np.array([3.45,2.3,4.5,6.9])\n A = np.random.standard_normal((4,4))\n B = np.diag(list(step)+[1])\n B[:4,:4] = A\n\n shape = (13,5,7,3)\n cmap = api.AffineTransform.from_params('ijkt', 'xyzt', B)\n\n data = np.random.standard_normal(shape)\n\n img = api.Image(data, cmap)\n\n save_image(img, tmpfile.name)\n img2 = load_image(tmpfile.name)\n yield assert_false, np.allclose(img.affine, img2.affine)\n yield assert_true, np.allclose(img.affine[:3,:3], img2.affine[:3,:3])\n yield assert_equal, img.shape, img2.shape\n yield assert_true, np.allclose(np.asarray(img2), np.asarray(img))\n\n# JT: nifti_ref doesn't reorder axes anymore so these tests\n# are no longer expected to work\n#\n# def test_save3():\n# # A test to ensure that when a file is saved, the affine\n# # and the data agree. In this case, things don't agree:\n# # i) the pixdim is off\n# # ii) makes the affine off\n\n# step = np.array([3.45,2.3,4.5,6.9])\n# shape = (13,5,7,3)\n# cmap = api.AffineTransform.from_start_step('jkli', 'tzyx', [0,3,5,1], step)\n\n# data = np.random.standard_normal(shape)\n# img = api.Image(data, cmap)\n# save_image(img, tmpfile.name)\n# img2 = load_image(tmpfile.name)\n\n# yield assert_equal, tuple([img.shape[l] for l in [3,0,1,2]]), img2.shape\n# a = np.transpose(np.asarray(img), [3,0,1,2])\n# yield assert_false, np.allclose(img.affine, img2.affine)\n# yield assert_true, np.allclose(a, np.asarray(img2))\n\n\n# def test_save4():\n# # Same as test_save3 except we have reordered the 'ijk' input axes.\n# shape = (13,5,7,3)\n# step = np.array([3.45,2.3,4.5,6.9])\n# # When the input coords are in the 'ljki' order, the affines get\n# # rearranged. Note that the 'start' below, must be 0 for\n# # non-spatial dimensions, because we have no way to store them in\n# # most cases. For example, a 'start' of [1,5,3,1] would be lost on\n# # reload\n# cmap = api.AffineTransform.from_start_step('lkji', 'tzyx', [2,5,3,1], step)\n# data = np.random.standard_normal(shape)\n# img = api.Image(data, cmap)\n# save_image(img, tmpfile.name)\n# img2 = load_image(tmpfile.name)\n# P = np.array([[0,0,0,1,0],\n# [0,0,1,0,0],\n# [0,1,0,0,0],\n# [1,0,0,0,0],\n# [0,0,0,0,1]])\n# res = np.dot(P, np.dot(img.affine, P.T))\n\n# # the step part of the affine should be set correctly\n# yield assert_array_almost_equal, res[:4,:4], img2.affine[:4,:4]\n\n# # start in the spatial dimensions should be set correctly\n# yield assert_array_almost_equal, res[:3,-1], img2.affine[:3,-1]\n\n# # start in the time dimension should not be 2 as in img, but 0\n# # because NIFTI dosen't have a time start\n\n# yield assert_false, (res[3,-1] == img2.affine[3,-1])\n# yield assert_true, (res[3,-1] == 2)\n# yield assert_true, (img2.affine[3,-1] == 0)\n\n# # shapes should be reversed because img has coordinates reversed\n\n\n# yield assert_equal, img.shape[::-1], img2.shape\n\n# # data should be transposed because coordinates are reversed\n\n# yield (assert_array_almost_equal, \n# np.transpose(np.asarray(img2),[3,2,1,0]),\n# np.asarray(img))\n\n# # coordinate names should be reversed as well\n\n# yield assert_equal, img2.coordmap.function_domain.coord_names, \\\n# img.coordmap.function_domain.coord_names[::-1]\n# yield assert_equal, img2.coordmap.function_domain.coord_names, \\\n# ['i', 'j', 'k', 'l']\n"
] | [
[
"numpy.array",
"numpy.allclose",
"numpy.random.standard_normal",
"numpy.asarray"
]
] |
marcovirgolin/pyNSGP | [
"4a9634161012d6ab39ce3d304dba943b6f7d9b29"
] | [
"pynsgp/Selection/Selection.py"
] | [
"import numpy as np\nfrom copy import deepcopy\nfrom numpy.random import randint\n\ndef TournamentSelect( population, how_many_to_select, tournament_size=4 ):\n\tpop_size = len(population)\n\tselection = []\n\n\twhile len(selection) < how_many_to_select:\n\n\t\tbest = population[randint(pop_size)]\n\t\tfor i in range(tournament_size - 1):\n\t\t\tcontestant = population[randint(pop_size)]\n\t\t\tif (contestant.rank < best.rank) or (contestant.rank == best.rank and contestant.crowding_distance > best.crowding_distance):\n\t\t\t\tbest = contestant\n\n\t\tsurvivor = deepcopy(best)\n\t\tselection.append(survivor)\n\n\treturn selection"
] | [
[
"numpy.random.randint"
]
] |
Aparna-Sakshi/sktime | [
"419d347f062320290fb65e4afec72b82179e63bf"
] | [
"sktime/classification/feature_based/tests/test_fresh_prince.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"FreshPRINCE test code.\"\"\"\nimport numpy as np\nfrom numpy import testing\nfrom sklearn.metrics import accuracy_score\n\nfrom sktime.classification.feature_based import FreshPRINCE\nfrom sktime.datasets import load_unit_test\n\n\ndef test_fresh_prince_on_unit_test_data():\n \"\"\"Test of FreshPRINCE on unit test data.\"\"\"\n # load unit test data\n X_train, y_train = load_unit_test(split=\"train\")\n X_test, y_test = load_unit_test(split=\"test\")\n indices = np.random.RandomState(0).choice(len(y_train), 10, replace=False)\n\n # train FreshPRINCE classifier\n fp = FreshPRINCE(\n random_state=0,\n default_fc_parameters=\"minimal\",\n n_estimators=10,\n save_transformed_data=True,\n )\n fp.fit(X_train, y_train)\n\n # assert probabilities are the same\n probas = fp.predict_proba(X_test.iloc[indices])\n testing.assert_array_almost_equal(probas, fp_classifier_unit_test_probas, decimal=2)\n\n # test train estimate\n train_probas = fp._get_train_probs(X_train, y_train)\n train_preds = fp.classes_[np.argmax(train_probas, axis=1)]\n assert accuracy_score(y_train, train_preds) >= 0.75\n\n\nfp_classifier_unit_test_probas = np.array(\n [\n [\n 0.2,\n 0.8,\n ],\n [\n 1.0,\n 0.0,\n ],\n [\n 0.1,\n 0.9,\n ],\n [\n 1.0,\n 0.0,\n ],\n [\n 0.9,\n 0.1,\n ],\n [\n 1.0,\n 0.0,\n ],\n [\n 0.9,\n 0.1,\n ],\n [\n 0.8,\n 0.2,\n ],\n [\n 0.9,\n 0.1,\n ],\n [\n 1.0,\n 0.0,\n ],\n ]\n)\n"
] | [
[
"numpy.argmax",
"numpy.random.RandomState",
"sklearn.metrics.accuracy_score",
"numpy.testing.assert_array_almost_equal",
"numpy.array"
]
] |
carderne/msoa-income | [
"2cfaef3e1942ba6f97b963cbc02472a154fae6d6"
] | [
"join.py"
] | [
"import sys\n\nimport pandas as pd\nimport geopandas as gpd\n\n\ndef main(csv, gpkg, out):\n df = pd.read_csv(csv).assign(\n Income=lambda x: pd.to_numeric(x.Income.str.replace(\",\", \"\"))\n )\n\n gpd.read_file(gpkg).get([\"MSOA01CD\", \"geometry\"]).merge(\n df, how=\"inner\", left_on=\"MSOA01CD\", right_on=\"MSOA\"\n ).to_file(out)\n\n\nif __name__ == \"__main__\":\n csv = sys.argv[1]\n gpkg = sys.argv[2]\n out = sys.argv[3]\n main(csv, gpkg, out)\n"
] | [
[
"pandas.read_csv"
]
] |
SamanKhamesian/Human-Activity-Recognition-Time-Series-Classification | [
"1b1d8474997ddf3c0f22791acecdfd823b9de5fd"
] | [
"Source/lstm.py"
] | [
"import os\n\nimport tensorflow as tf\nfrom keras.layers import LSTM, Dense, Dropout\nfrom keras.models import Sequential\n\nfrom Source.config import Model\nfrom Source.driver import Driver\n\ntf.logging.set_verbosity(tf.logging.ERROR)\nos.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n\n\ndef run():\n dataset = Driver()\n\n n_time_steps = dataset.x_train.shape[1]\n n_output = dataset.y_train.shape[1]\n n_features = dataset.x_train.shape[2]\n\n model = LSTMModel(n_time_steps, n_output, n_features)\n model.fit(x_train=dataset.x_train, y_train=dataset.y_train)\n\n accuracy = model.evaluate(x_test=dataset.x_test, y_test=dataset.y_test)\n print('Accuracy = %{0:.4f}'.format(accuracy * 100))\n print(model.model.summary())\n\n\nclass LSTMModel:\n def __init__(self, n_time_steps, n_output, n_features):\n self.model = Sequential()\n self.model.add(LSTM(units=Model.N_NODES, input_shape=(n_time_steps, n_features)))\n # Use Dropout layer to reduce overfitting of the model to the training data\n self.model.add(Dropout(Model.DROPOUT_RATE))\n self.model.add(Dense(Model.N_NODES, activation='relu'))\n # Add output layer with 6 (Total number of classes) nodes with softmax activation function\n self.model.add(Dense(n_output, activation='softmax'))\n # Compile model\n self.model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n\n def fit(self, x_train, y_train, epochs=15, batch_size=64, verbose=0):\n self.model.fit(x=x_train, y=y_train, epochs=epochs, batch_size=batch_size, verbose=verbose)\n\n def predict(self, x_test, batch_size=64):\n return self.model.predict(x=x_test, batch_size=batch_size)\n\n def evaluate(self, x_test, y_test, batch_size=64, verbose=0):\n _, accuracy = self.model.evaluate(x=x_test, y=y_test, batch_size=batch_size, verbose=verbose)\n return accuracy\n\n\nif __name__ == '__main__':\n run()\n"
] | [
[
"tensorflow.logging.set_verbosity"
]
] |
UWSEDS-aut17/uwseds-group-maximize-savings-in-clean-energy | [
"c485c5e1f5bea1135b013835d28227f858a68c4d"
] | [
"sundial/price_model/parameter_tuning.py"
] | [
"import numpy as np\nfrom matplotlib import pyplot as plt\nimport seaborn as sns\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import linear_model\nfrom sklearn import neighbors\nfrom sklearn import svm\nfrom sklearn.model_selection import GridSearchCV\nfrom sundial.price_model.utils.file_utils import *\nfrom sundial.price_model.utils.settings import *\nimport multiprocessing\n\n\ndef get_train_test_data(df_price_frame):\n df_price_frame = df_price_frame.dropna()\n X_price_frame = df_price_frame.drop('lmp_value', axis=1).\\\n reset_index().drop('time', axis=1)\n Y_price_frame = df_price_frame['lmp_value']\n return train_test_split(X_price_frame, Y_price_frame, shuffle=False)\n\n\ndef tune_models(df_price_frame):\n \"\"\"\n tune models using different regressors\n :param df_price_frame:\n :return:\n \"\"\"\n x_train, x_test, y_train, y_test = \\\n get_train_test_data(df_price_frame)\n tune_svr(x_train, y_train, x_test, y_test)\n tune_knn(x_train, y_train, x_test, y_test)\n tune_lin_reg(x_train, y_train, x_test, y_test)\n\n\ndef tune_svr(x_train, y_train, x_test, y_test):\n \"\"\"\n SVR regressor with grid search\n :param x_train:\n :param y_train:\n :param x_test:\n :param y_test:\n :return:\n \"\"\"\n C_range = range(1000, 3000, 1000)\n tuned_parameters = [{\n \"C\": C_range,\n \"kernel\": [\"rbf\"]\n }]\n svr_reg = GridSearchCV(svm.SVR(gamma=0.001, epsilon=10),\n param_grid=tuned_parameters, verbose=1,\n n_jobs=multiprocessing.cpu_count())\n y_pred = svr_reg.fit(x_train, y_train).predict(x_test)\n\n print('Optimum parameters epsilon and kernel for SVR: ',\n svr_reg.best_params)\n\n print(\"The test score R2 for SVR: \", svr_reg.score(x_test, y_test))\n\n print(\"SVR mean squared error: %.2f\"\n % np.mean((y_test - svr_reg.predict(x_test)) ** 2))\n\n target_folder = os.path.join(PLOTS_FOLDER, \"svr\")\n make_dir(target_folder)\n plot_predictions(x_test, y_test, y_pred, \"svr\", target_folder)\n plot_pred_test_relation(y_test, y_pred, \"svr\", target_folder)\n\n\ndef tune_knn(x_train, y_train, x_test, y_test):\n \"\"\"\n KNN regressor with grid search\n :param x_train:\n :param y_train:\n :param x_test:\n :param y_test:\n :return:\n \"\"\"\n n_range = range(1, 10, 1)\n tuned_parameters = [{\n \"n_neighbors\": n_range\n }]\n knn_reg = GridSearchCV(neighbors.KNeighborsRegressor(),\n param_grid=tuned_parameters, verbose=1,\n n_jobs=multiprocessing.cpu_count())\n y_pred = knn_reg.fit(x_train, y_train).predict(x_test)\n\n print('Optimum parameters epsilon and kernel for KNN: ',\n knn_reg.best_params_)\n\n print(\"The test score R2 for KNN: \", knn_reg.score(x_test, y_test))\n\n print(\"KNN mean squared error: %.2f\"\n % np.mean((y_test - knn_reg.predict(x_test)) ** 2))\n\n target_folder = os.path.join(PLOTS_FOLDER, \"knn\")\n make_dir(target_folder)\n plot_predictions(x_test, y_test, y_pred, \"knn\", target_folder)\n plot_pred_test_relation(y_test, y_pred, \"knn\", target_folder)\n\n\ndef tune_lin_reg(x_train, y_train, x_test, y_test):\n \"\"\"\n Linear regressor with grid search\n :param x_train:\n :param y_train:\n :param x_test:\n :param y_test:\n :return:\n \"\"\"\n lin_reg = linear_model.LinearRegression(normalize=True)\n y_pred = lin_reg.fit(x_train, y_train).predict(x_test)\n\n print(\"The test score R2 for Lin Reg: \", lin_reg.score(x_test, y_test))\n\n print(\"Lin Reg mean squared error: %.2f\"\n % np.mean((y_test - lin_reg.predict(x_test)) ** 2))\n\n target_folder = os.path.join(PLOTS_FOLDER, \"lin\")\n make_dir(target_folder)\n plot_predictions(x_test, y_test, y_pred, \"lin\", target_folder)\n plot_pred_test_relation(y_test, y_pred, \"lin\", target_folder)\n\n\ndef plot_predictions(x_test, y_test, y_pred, model_name, path):\n \"\"\"\n plot predictions from models\n :param x_test:\n :param y_test:\n :param y_pred:\n :param model_name:\n :param path:\n :return:\n \"\"\"\n plt.figure(figsize=(15, 7))\n plt.scatter(x_test.index, y_test, c='k', label='Observed')\n plt.plot(x_test.index, y_pred, c='r', label='Predicted')\n plt.xlabel('data')\n plt.ylabel('lmp_value')\n plt.title(model_name)\n plt.legend()\n plt.savefig(os.path.join(path, \"{0}_predictions\".format(model_name)))\n\n\ndef plot_pred_test_relation(y_test, y_pred, model_name, path):\n \"\"\"\n plot the confusion matrix type graph\n :param y_test:\n :param y_pred:\n :param model_name:\n :param path:\n :return:\n \"\"\"\n plt.figure(figsize=(6, 6))\n plt.scatter(y_test, y_test, c='k')\n plt.scatter(y_test, y_pred, c='r')\n plt.xlabel('Observed Elec. Price (MWhr)')\n plt.ylabel(\"Predicted Elec. Price (MWWh): $\\hat{Y}_i$\")\n plt.title(\"Energy vs Predicted Energy: $Y_i$ vs $\\hat{Y}_i$ \" + model_name)\n plt.savefig(os.path.join(path, \"{0}_relation\".format(model_name)))\n\n\ndef main():\n price_frame = pd.read_csv(PRICE_DATA_FILENAME, index_col=0)\n df_price_frame = price_frame.set_index(\"time\")\n tune_models(df_price_frame)\n\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"matplotlib.pyplot.legend",
"sklearn.neighbors.KNeighborsRegressor",
"pandas.read_csv",
"matplotlib.pyplot.figure",
"sklearn.svm.SVR",
"sklearn.linear_model.LinearRegression",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.title",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.plot",
"sklearn.model_selection.train_test_split",
"matplotlib.pyplot.scatter"
]
] |
yosukefk/plotter | [
"16127ee7fc3105c717e92875ee3d61477bd41533"
] | [
"demo/work_pretty_trio.py"
] | [
"#!/usr/bin/env python3\nimport sys\n\nplotterdir = '..'\nsys.path.insert(0, plotterdir)\n\nfrom plotter import calpost_reader\nimport plotter.plotter_multi as plotter_multi\nfrom plotter.plotter_util import LambertConformalTCEQ\nfrom plotter.plotter_background import BackgroundManager\nimport cartopy.crs as ccrs\n\nimport geopandas as gpd\nimport matplotlib as mpl\nimport matplotlib.colors as colors\nfrom shapely.geometry import Polygon\nfrom adjustText import adjust_text\n\nimport numpy as np\n\nfrom pathlib import Path\nfrom multiprocessing import Pool\nimport shlex\nimport subprocess\nimport socket\nimport sys\n\n# save better resolution image \nmpl.rcParams['savefig.dpi'] = 300\n\n# input directory/file names\nddir = Path(plotterdir) / 'data'\n\n# input file names\nif len(sys.argv) > 1:\n site = sys.argv[1].upper()\nelse:\n site = 'S2'\nfnames = [\n 'tseries_ch4_1min_conc_toy_all.dat',\n f'tseries_ch4_1min_conc_un_co_{site.lower()}.dat', # continuous upset\n f'tseries_ch4_1min_conc_un_pu_{site.lower()}.dat', # pulsate upset\n ]\n\n# intermediate\nwdir = Path('./img9')\n\n# output\nodir = Path('.')\noname = f'tseries_ch4_1min_conc_co_all_un_{site.lower()}.mp4'\n\n# prep workdir\nif not wdir.is_dir():\n wdir.mkdir()\nelse:\n for f in wdir.glob('*.png'):\n try:\n f.unlink()\n except OSError as e:\n print(\"Error: %s : %s\" % (f, e.strerror))\n\n# aux inputs\nbgfile = Path(plotterdir) / 'resources/naip_toy_pmerc_5.tif'\nshpfile = Path(plotterdir) / 'resources/emitters.shp'\n\n\n# source locations\ndf_shp = gpd.read_file(shpfile)\ndf_shp = df_shp.to_crs('EPSG:3857')\n\n# title to use for each input\ntitles = ['Regular Sources', f'Unintended,\\nContinuous {site}',\n f'Unintended,\\nPulsated {site}']\n\n# read the data\ndata = []\nfor fname in fnames:\n with open(ddir / fname) as f:\n dat = calpost_reader.Reader(f)\n data.append(dat)\n\n# grab necessary info\narrays = [dat['v'] for dat in data]\ntstamps = data[0]['ts']\ngrid = data[0]['grid']\n\n# get horizontal extent \nextent = [\n grid['x0'], grid['x0'] + grid['nx'] * grid['dx'],\n grid['y0'], grid['y0'] + grid['ny'] * grid['dy'],\n]\n\n# distance in calpost is in km\nextent = [_ * 1000 for _ in extent]\nx = dat['x'] * 1000\ny = dat['y'] * 1000\n\n# convert unit of array from g/m3 tp ppb\n# mwt g/mol\n# molar volume m3/mol\narrays = [arr / 16.043 * 0.024465403697038 * 1e9 for arr in arrays]\n\n# Mrinali/Gary's surfer color scale\ncmap = colors.ListedColormap([\n '#D6FAFE', '#02FEFF', '#C4FFC4', '#01FE02',\n '#FFEE02', '#FAB979', '#EF6601', '#FC0100', ])\ncmap.set_under('#FFFFFF')\ncmap.set_over('#000000')\n# Define a normalization from values -> colors\nbndry = [1, 10, 50, 100, 200, 500, 1000, 2000]\nnorm = colors.BoundaryNorm(bndry, len(bndry))\n\nplotter_options = {\n 'background_manager': BackgroundManager(bgfile=bgfile,),\n 'contour_options': {\n 'levels': bndry,\n 'cmap': cmap,\n 'norm': norm,\n 'alpha': .5,\n 'extend': 'max',\n },\n 'title_options': {'fontsize': 'medium'},\n 'colorbar_options': None,\n 'customize_once': [\n # emission points\n lambda p: df_shp.plot(ax=p.ax, column='kls', categorical=True, legend=False, zorder=10,\n markersize=2,\n # got red/blue/yellow from colorbrewer's Set1\n cmap=colors.ListedColormap(['#e41a1c', '#377eb8', '#ffff33'])\n ),\n # Shannon's \"original\" box\n lambda p: p.ax.add_geometries(\n [Polygon([(-101.8834373, 31.71350603),\n (-101.8664281, 31.71727773),\n (-101.8748762, 31.75052556),\n (-101.8942724, 31.74599821),\n (-101.8834373, 31.71350603),\n ])],\n crs=ccrs.PlateCarree(), facecolor='none', edgecolor='white', lw=.6,\n ),\n # modeled box\n lambda p: p.ax.add_geometries(\n [Polygon([(extent[x], extent[y]) for x, y in ((0, 2), (0, 3), (1, 3), (1, 2), (0, 2))])],\n crs=LambertConformalTCEQ(), facecolor='none', edgecolor='white', lw=.6, ls='--',\n ),\n\n ]}\n\n# clone the options and let each has own title\nplotter_options = [{**plotter_options, 'title': title} for title in titles]\n\n# colorbar goes to entire figure\nfigure_options = {\n 'colorbar_options': {\n 'label': r'$CH_4$ (ppbV)',\n }\n }\n\n# make a plot template\np = plotter_multi.Plotter(arrays=arrays, tstamps=tstamps, \n x=x, y=y, projection=LambertConformalTCEQ(),\n plotter_options=plotter_options,\n figure_options=figure_options)\n\n\n# make single image file (for QA)\nntsteps = len(tstamps)\np.savefig((odir / oname).with_suffix('.png'), \n tidx=min(16*60,ntsteps-1))\n\n# make mpeg file\np.savemp4(odir / oname, wdir=wdir )\n"
] | [
[
"matplotlib.colors.ListedColormap"
]
] |
humans-to-robots-motion/lgp | [
"f62da0c0cb7a209eb90848cce8eddc91c14fa099"
] | [
"lgp/geometry/transform.py"
] | [
"import numpy as np\nfrom pyrieef.geometry.differentiable_geometry import DifferentiableMap\n\n\nclass LinearTranslation(DifferentiableMap):\n \"\"\"\n Simple linear translation\n \"\"\"\n\n def __init__(self, p0=np.zeros(2)):\n assert isinstance(p0, np.ndarray)\n self._p = p0\n\n def forward(self, q):\n assert q.shape[0] == self.input_dimension\n return self._p + q\n\n def backward(self, p): # p is coordinate in parent frame\n assert p.shape[0] == self.output_dimension\n return p - self._p\n\n def jacobian(self, q):\n assert q.shape[0] == self.input_dimension\n return np.eye(self.input_dimension)\n\n @property\n def input_dimension(self):\n return self._p.shape[0]\n\n @property\n def output_dimension(self):\n return self.input_dimension\n"
] | [
[
"numpy.eye",
"numpy.zeros"
]
] |
MGarrod1/rgg_ensemble_analysis | [
"679ea7b11c0eae4d92eef9f08fe9c63dcfd3837c"
] | [
"rgg_ensemble_analysis/Statistics_Computation.py"
] | [
"\"\"\"\n\nFunctions to compute various statistics of the data\nand their associated errors.\n\n\"\"\"\n\n\n#Compute statistics about the variance of an estimator:\n\nimport numpy as np \nfrom scipy import stats\nimport math\n\n#The following functions as involved in estimating the standard \n\ndef Moment(Sample,k) :\n\n\t\"\"\"\n\tThis function computes the kth moment of the\n\tSample.\n\t\n\t\"\"\"\n\tMean = np.mean(Sample)\n\t\n\tMoment = 0.0\n\tfor i in range(0,len(Sample) ) :\n\t\tMoment = Moment + (Mean - Sample[i] )**k \n\t\t\n\treturn Moment/(len(Sample))\n\t\ndef D4(Sample) :\n\t\"\"\"Compute the fourth central moment of a sample\n\tSee: https://en.wikipedia.org/wiki/Central_moment\n\tfor defintion\"\"\"\n\tM = float( len(Sample) )\n\tD4 = ((M-1)/(M**3))*( (M**2 - 3*M + 3)*Moment(Sample,4) + 3*(2*M -3)*Moment(Sample,2)**2 )\n\t\n\treturn D4\n\t\ndef VarSE(Sample) :\n\n\n\t\"\"\"\n\tReturns the standard error on the variance of the sample given.\n\t\n\tFormula taken from: \n\tWonnapinij, Passorn, Patrick F. Chinnery, and David C. Samuels. \"Previous estimates of mitochondrial DNA mutation level variance \tdid not account for sampling error: comparing the mtDNA genetic bottleneck in mice and humans.\" The American Journal of Human \tGenetics 86.4 (2010): 540-550.\n\t\n\tParameters\n\t-----------\n\t\n\tSample : list\n\t\n\tlist of values\n\t\n\tReturns\n\t-----------\n\t\n\tSE : float\n\t\n\tStandard error on the variance of a sample\n\t\n\t\n\t\"\"\"\n\n\n\tM = float( len(Sample) )\n\t\n\tSE = ( (1.0/M)*(D4(Sample) - ( (M-3)/(M-1) )*np.var(Sample)**2 ) )**0.5\n\n\treturn SE\n\t\ndef CV(Sample) : \n\n\t\"\"\"\n\tComputes the coefficient of variation of the values.\n\t\n\tArguments\n\t------------\n\t\n\tSample : list\n\t\n\t\n\t\"\"\"\n\treturn np.std(Sample)/np.mean(Sample)\n\t\ndef CV_Error(Sample) :\n\t\"\"\"\n\tCompute the standard error on the coefficient of variation.\n\t\"\"\"\n\ttry :\n\t\tpart1 = (VarSE(Sample)/( 2.0*(np.var(Sample)**0.5)*np.mean(Sample) ) )**2\n\t\tpart2 = ( (((np.var(Sample))**0.5 )*stats.sem(Sample)/(np.mean(Sample)**2) ) )**2\n\t\tCoeff_ERR = ( part1 + part2 )**0.5\n\texcept :\n\t\tprint(\"Error encountered\")\n\t\tprint(\"Sample length = \" + str(len(Sample)))\n\t\tprint(\"Setting error to zero by defulat\")\n\t\tCoeff_ERR = 0.0\n\n\n\treturn Coeff_ERR\n\t\n\n\t\n#Bootsrapping Tools:\n\n#Given a sample we can estimate the standard error in the variance\ndef Bootstrap_SE(Sample,Redraws) :\n\tData_Points = len(Sample)\n\tVar = np.var(Sample)\n\n\tVars = [ ]\n\t\n\tfor j in range(0,Redraws) : \n\t\tSample2 = [ ]\n\t\tfor i in range(0,(len(Sample))) :\n\t\t\t#Draw a random integar less than the sample size\n\t\t\tEntry = int(math.floor( np.random.uniform(0, (len(Sample)), 1) ) )\n\t\t\tSample2.append(Sample[Entry]) \n\t\tNew_Var = np.var(Sample2)\n\t\tVars.append(New_Var)\n\t\n\t \n\t\n\tVar_SE = stats.sem(Vars)\n\t\t\n\treturn (Redraws**0.5)*Var_SE\n\t\ndef Bootstrap_Mean_SE(Sample,Redraws) :\n\tData_Points = len(Sample)\n\t\n\tMean = np.mean(Sample)\n\n\tMeans = [ ]\n\t\n\tfor j in range(0,Redraws) : \n\t\tSample2 = [ ]\n\t\t\n\t\tfor i in range(0,(len(Sample))) :\n\t\t\t#Draw a random integar less than the sample size\n\t\t\tEntry = int(math.floor( np.random.uniform(0, (len(Sample)), 1) ) )\n\t\t\tSample2.append(Sample[Entry]) \n\t\t\t\t\n\t\tNew_Mean = np.mean(Sample2)\n\t\tMeans.append(New_Mean)\n\t\n\t \n\t\n\tMean_SE = stats.sem(Means)\n\tBoot_Mean = np.mean(Means)\n\t\t\n\treturn (Redraws**0.5)*Mean_SE\n\t\n\n\ndef Get_Spearman_Correlation(Array_1, Array_2, P_Val_Threshold=(10 ** (-4))):\n\t\n\t\"\"\"\n\tReturns the correlation between two arrays.\n\n\tIf p val > 10^-4 we simply report the correlation as zero\n\t\n\tParameters\n\t--------------\n\t\n\tArray_1 : list\n\t\n\t\n\tArray_2 : list\n\t\n\tP_Val_Threshold :float\n\t\n\tSet a threshold for the p-value. If the p value\n\tif greater than this threshold then we can set\n\tthe correlation to zero (ie. we are not confident\n\tthat the correlation exists). \n\n\t\"\"\"\n\t\n\tP_Val_Threshold = 1.1\n\tCorrelation, pval = stats.spearmanr(Array_1, Array_2)\n\n\tif pval < P_Val_Threshold:\n\t\treturn Correlation\n\n\telse:\n\t\treturn 0.0\n\n\ndef Bootstrap_Correlation_Confid_Int(Sample_1, Sample_2, Redraws=50):\n\t\"\"\"\n\n\tUse the bootstrapping method to estimate the confidence interval on the\n\tSpearman Correlation\n\n\tReturns the 95% confidence interval by default\n\n\t(Does p-value threshold want to be an additional argument?)\n\n\tParameters\n\t--------------\n\n\tSample_1 : list\n\n\tFirst sample\n\n\tSample_2 : list\n\n\tSecond sample\n\n\tRedraws : int\n\n\tNumber of times to same with replacement from the joint distribution\n\tof sample_1 and sample_2\n\n\n\tReturns\n\t-----------\n\n\t95% confidence interval on the Spearman correlation.\n\n\t\"\"\"\n\n\tData_Points = len(Sample_1)\n\n\tOriginal_Correlation = Get_Spearman_Correlation(Sample_1, Sample_2, P_Val_Threshold=20.0)\n\n\tCorrelations = []\n\tDifferences = []\n\n\tfor j in range(0, Redraws):\n\t\tSample2 = []\n\n\t\tRedraw_Sample_1 = []\n\t\tRedraw_Sample_2 = []\n\n\t\t# Redraw the samples:\n\t\tfor i in range(0, (len(Sample_1))):\n\t\t\t#Redraw pairs of values:\n\t\t\tEntry = int(math.floor(np.random.uniform(0, (len(Sample_1)), 1)))\n\t\t\tRedraw_Sample_1.append(Sample_1[Entry])\n\t\t\tRedraw_Sample_2.append(Sample_2[Entry])\n\n\t\tRedrawn_Correlation = Get_Spearman_Correlation(Redraw_Sample_1, Redraw_Sample_2, P_Val_Threshold=20.0)\n\t\tCorrelations.append(Redrawn_Correlation)\n\t\tDifferences.append(Redrawn_Correlation - Original_Correlation)\n\n\t# sort the list of differences:\n\tSorted_Differences = np.sort(Differences)\n\t\n\treturn Sorted_Differences[int(math.ceil(0.95 * len(Differences)))]\n\n\n"
] | [
[
"numpy.var",
"scipy.stats.sem",
"numpy.sort",
"numpy.std",
"scipy.stats.spearmanr",
"numpy.mean"
]
] |
liggest/RGBDFace | [
"75768b1848f03d3e9d53913546b19cce0b1ada67"
] | [
"RGBDFace/utils/face.py"
] | [
"import numpy as np\n# import open3d as o3d\nimport face_recognition\n# import cv2\nfrom skimage import draw #,morphology\n\n\n# from .depth import depthPreprocess\nfrom .image import getConvexHullMask,getMaskedImg2, maskClosing,maskDilation,maskErosion\n\ndef faceLandmarks(image):\n '''\n 人脸边框+特征点\n '''\n image=np.asarray(image)\n locations=face_recognition.face_locations(image)\n if not locations:\n return None,None\n landmarks=face_recognition.face_landmarks(image,face_locations=locations)\n return locations,landmarks\n\ndef getLandmarkPoints(landmarks):\n '''\n 将特征点变成列表形式\n '''\n facePoints=None\n for face in landmarks:\n for v in face.values():\n if facePoints is None:\n facePoints=np.asarray(v)\n else:\n facePoints=np.vstack([facePoints,np.asarray(v)])\n return facePoints\n\ndef depthFilter(points,depth,dthreshold=1.0):\n '''\n 过滤无深度的点，计算有深度的点在所有点中的比例\n '''\n depth=np.asarray(depth)\n imSize=depth.shape # h,w\n l=len(points)\n pnum=0\n #resultPoints=[None]*l\n resultPoints=[ np.asarray([np.nan,np.nan]) ]*l\n for i,p in enumerate(points):\n if 0<=p[1]<imSize[0] and 0<=p[0]<imSize[1] and 0<depth[p[1],p[0]]<=dthreshold:\n resultPoints[i]=p\n pnum+=1\n #resultPoints=np.asarray(resultPoints,dtype=np.object)\n resultPoints=np.asarray(resultPoints) # dtype:float64\n return resultPoints,pnum/l\n\ndef processFaceRGBD(rgbd,depthThreshold=1.0,rateThreshold=0.75):\n '''\n 从RGBD图像中得到人脸边框、特征点（语义字典）、特征点（点集）、深度筛选过的特征点、有深度特征点的比例\n '''\n return processFaceImgPair(rgbd.color,rgbd.depth,depthThreshold=depthThreshold,rateThreshold=rateThreshold)\n\ndef processFaceImgPair(color,depth,depthThreshold=1000,rateThreshold=0.75):\n '''\n 从color、depth图像对中得到人脸边框、特征点（语义字典）、特征点（点集）、深度筛选过的特征点、有深度特征点的比例\n '''\n locations,landmarks=faceLandmarks(color)\n if locations is None:\n print(\"未检测到人脸\")\n return False,None,None,None,None,None\n facePoints=getLandmarkPoints(landmarks)\n facePointsFilt,depthRate=depthFilter(facePoints,depth,dthreshold=depthThreshold)\n if depthRate<rateThreshold:\n print(\"脸部特征点中有深度的点所占比例小于阈值\")\n return False,None,None,None,None,None\n #facePoints=np.asarray(facePoints,dtype=np.object)\n return True,locations,landmarks,facePoints,facePointsFilt,depthRate\n\ndef getCorrespondence(points,points2):\n '''\n 得到两点集的对应点（下标相同且不为[nan,nan]）\n '''\n minlen=min( points.shape[0],points2.shape[0] )\n points=points[:minlen,:]\n points2=points2[:minlen,:]\n return np.where( ~np.isnan(points).any(axis=1) & ~np.isnan(points2).any(axis=1) )[0]\n\n\n# def getCorrespondence2(points,points2):\n# '''\n# 得到两点集的对应点（下标相同且不为None）\n# '''\n# minlen=min(points.shape[0],points2.shape[0])\n# corrIdxs=[]\n# for i in range(minlen):\n# if not(points[i] is None or points2[i] is None):\n# corrIdxs.append(i)\n# return np.asarray(corrIdxs)\n\n\ndef getFaceCircle(img,facePoints,faceConvexHull,rRate=1.2):\n '''\n 通过人脸特征点，得到包裹脸的圆形遮罩\n '''\n idxs=np.asarray( np.where(faceConvexHull>0.5) )\n centroid=np.sum(idxs,axis=1)/idxs.shape[1] #质心\n distances=np.linalg.norm(facePoints-centroid[::-1],axis=1) #[x y]\n maxDistance=distances.max()\n r=maxDistance*rRate\n center=np.int_(centroid) # [y x]\n cr,cc=draw.disk(center,r,shape=img.shape) # [y x]\n mask=np.zeros_like(img,dtype=np.bool)\n mask[cr,cc]=True\n\n #试着在圆上接个方块\n # p1=np.asarray( [center[0],center[1]-int(r)],dtype=np.int64 )\n # p2=np.asarray( [-1,center[1]+int(r)],dtype=np.int64 )\n # cr,cc=draw.rectangle(start=p1,end=p2,shape=img.shape)\n # mask[cr,cc]=True\n mask[:center[0]+1,center[1]-int(r):center[1]+int(r)+1]=True\n\n return mask\n\ndef getFaceMask(depth,landmarks,facePoints=None,circleRate=1.2):\n '''\n 通过人脸特征点，得到包裹脸的圆形遮罩（除去眼、嘴）\n '''\n leftEye= np.asarray( landmarks[0][\"left_eye\"] )\n rightEye= np.asarray( landmarks[0][\"right_eye\"] )\n mouth= set(landmarks[0][\"top_lip\"]).union( set(landmarks[0][\"bottom_lip\"]) )\n mouth=np.asarray(list(mouth))\n leftEyeMask=getConvexHullMask(depth,leftEye)\n rightEyeMask=getConvexHullMask(depth,rightEye)\n mouthMask=getConvexHullMask(depth,mouth)\n fullMask=leftEyeMask | rightEyeMask | mouthMask\n # disk=morphology.disk(10)\n # disk=morphology.disk(12)\n # fullMaskDila=morphology.binary_dilation(fullMask,selem=disk) \n fullMaskDila=maskDilation(fullMask,size=12) #膨胀嘴、脸遮罩\n\n if facePoints is None:\n facePoints=getLandmarkPoints(landmarks)\n \n faceConvexHull=getConvexHullMask(depth,facePoints)\n faceCircleMask=getFaceCircle(np.asarray(depth),facePoints,faceConvexHull,rRate=circleRate)\n faceMask=faceCircleMask ^ fullMaskDila #取相异的部分，即圆里扣去眼、嘴\n return faceCircleMask,faceMask,faceConvexHull\n\ndef getFaceMeanMask(depth,faceConvexHull,depthMask,maxMeanDiff=100):\n '''\n 以人脸特征点组成的凸包为范围，求人脸的深度均值，得到能够滤除均值+-maxMeanDiff范围外深度的遮罩\n '''\n # disk=morphology.disk(5)\n # disk=morphology.disk(10)\n # faceConvexHulle=morphology.binary_erosion(faceConvexHull,selem=disk) \n faceConvexHulle=maskErosion(faceConvexHull,size=10) #腐蚀\n idxs=np.where(faceConvexHulle>0.5)\n faceMean= np.mean( depth[idxs[0],idxs[1]] )\n faceMeanMask=np.asarray( (depth>faceMean-maxMeanDiff )&(depth<faceMean+maxMeanDiff ) & depthMask )\n return faceMeanMask\n\n\n# def processDepth(depth,landmarks,facePoints,cropEyeMouth=True,\n# dmin=100,dmax=1000,filtSize=6,bifiltSize=5,circleRate=1.2,maxMeanDiff=100):\n# '''\n# 预处理深度图像，使用圆形遮罩切出头部，视情况施加遮罩切除眼、嘴 \n# 返回处理后的完整深度图、头部、剩余部分、遮罩列表（完整深度遮罩、脸部遮罩（切除眼、嘴）、脸部圆形遮罩） \n# '''\n# depth,depthMask=depthPreprocess(depth,dmin,dmax,filtSize,bifiltSize)\n# if cropEyeMouth:\n# faceCircleMask,faceMask,faceConvexHull=getFaceMask(depth,landmarks,facePoints,circleRate)\n# else:\n# faceConvexHull=getConvexHullMask(depth,facePoints)\n# faceCircleMask=getFaceCircle(depth,facePoints,faceConvexHull,circleRate)\n# faceMask=faceCircleMask\n\n# faceMeanMask=getFaceMeanMask(depth,faceConvexHull,depthMask,maxMeanDiff=maxMeanDiff) #在脸部均值 +-10cm以外的都会被切掉\n \n# depthMask &=faceMeanMask\n# disk=morphology.disk(2)\n# depthMask=morphology.binary_erosion(depthMask,selem=disk) #腐蚀\n# depthTmp=getMaskedImg2(depth,depthMask)\n\n# masked=getMaskedImg2(depthTmp,faceMask)\n# maskedReverse=getMaskedImg2(depthTmp,faceCircleMask,reverse=True)\n# depthTmp=depthTmp.astype(np.uint16)\n# masked=masked.astype(np.uint16)\n# maskedReverse=maskedReverse.astype(np.uint16)\n# return depthTmp,masked,maskedReverse,[depthMask,faceMask,faceCircleMask,faceConvexHull]\n\ndef processFaceDepth(depth,depthMask,landmarks,facePoints,cropEyeMouth=True,\n circleRate=1.2,maxMeanDiff=100):\n '''\n 预处理深度图像，使用圆形遮罩切出头部，视情况施加遮罩切除眼、嘴 \n 返回处理后的完整深度图、头部、剩余部分、遮罩列表（完整深度遮罩、脸部遮罩（切除眼、嘴）、脸部圆形遮罩） \n '''\n #depth,depthMask=depthPreprocess(depth,dmin,dmax,filtSize,bifiltSize)\n if cropEyeMouth:\n faceCircleMask,faceMask,faceConvexHull=getFaceMask(depth,landmarks,facePoints,circleRate)\n else:\n faceConvexHull=getConvexHullMask(depth,facePoints)\n faceCircleMask=getFaceCircle(depth,facePoints,faceConvexHull,circleRate)\n faceMask=faceCircleMask\n\n faceMeanMask=getFaceMeanMask(depth,faceConvexHull,depthMask,maxMeanDiff=maxMeanDiff) #在脸部均值 +-10cm以外的都会被切掉\n \n depthMask &=faceMeanMask\n # disk=morphology.disk(2)\n # depthMask=morphology.binary_erosion(depthMask,selem=disk) #腐蚀\n # depthMask=maskClosing(depthMask,size=4)\n depthMask=maskErosion(depthMask,size=2) #腐蚀\n depthTmp=getMaskedImg2(depth,depthMask)\n\n masked=getMaskedImg2(depthTmp,faceMask)\n maskedReverse=getMaskedImg2(depthTmp,faceCircleMask,reverse=True)\n depthTmp=depthTmp.astype(np.uint16)\n masked=masked.astype(np.uint16)\n maskedReverse=maskedReverse.astype(np.uint16)\n return depthTmp,masked,maskedReverse,[depthMask,faceMask,faceCircleMask,faceConvexHull]\n"
] | [
[
"numpy.zeros_like",
"numpy.sum",
"numpy.asarray",
"numpy.int_",
"numpy.isnan",
"numpy.where",
"numpy.linalg.norm",
"numpy.mean"
]
] |
defensetongxue/pyGAT | [
"5677b15be986b0650b883cdd20dbfb1bb486d6f5"
] | [
"utils.py"
] | [
"import numpy as np\nimport scipy.sparse as sp\nimport torch\nimport json as js\nimport pandas as pd \ndef encode_onehot(labels):\n # The classes must be sorted before encoding to enable static class encoding.\n # In other words, make sure the first class always maps to index 0.\n classes = sorted(list(set(labels)))\n classes_dict = {c: np.identity(len(classes))[i, :] for i, c in enumerate(classes)}\n labels_onehot = np.array(list(map(classes_dict.get, labels)), dtype=np.int32)\n return labels_onehot\n\n\ndef load_data(path=\"./data/cora/\", dataset=\"cora\"):\n \"\"\"Load citation network dataset (cora only for now)\"\"\"\n print('Loading {} dataset...'.format(dataset))\n if dataset=='cora':\n idx_features_labels = np.genfromtxt(\"{}{}.content\".format(path, dataset), dtype=np.dtype(str))\n features = sp.csr_matrix(idx_features_labels[:, 1:-1], dtype=np.float32)\n labels = encode_onehot(idx_features_labels[:, -1])\n\n # build graph\n idx = np.array(idx_features_labels[:, 0], dtype=np.int32)\n idx_map = {j: i for i, j in enumerate(idx)}\n edges_unordered = np.genfromtxt(\"{}{}.cites\".format(path, dataset), dtype=np.int32)\n edges = np.array(list(map(idx_map.get, edges_unordered.flatten())), dtype=np.int32).reshape(edges_unordered.shape)\n adj = sp.coo_matrix((np.ones(edges.shape[0]), (edges[:, 0], edges[:, 1])), shape=(labels.shape[0], labels.shape[0]), dtype=np.float32)\n\n # build symmetric adjacency matrix\n adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)\n\n idx_train = range(140)\n idx_val = range(200, 500)\n idx_test = range(500, 1500)\n \n else: # dataset is chamelon\n file_prefix='./data/chameleon/chameleon_'\n feature_file=open(file_prefix+'features.json','r')\n data=js.load(feature_file)\n features=[]\n node_number=2277\n for i in range(node_number):\n features.append(data[str(i)])\n file_label=open(file_prefix+'target.csv','r')\n labels=pd.read_csv(file_label)\n labels=np.array(labels.target)\n file_label=open(file_prefix+'edges.csv','r')\n edges=pd.read_csv(file_label)\n adj=np.eye(node_number)\n for i,j in zip(edges.id1,edges.id2):\n adj[i][j]=adj[j][i]=1\n \n features = normalize_features(features)\n adj = normalize_adj(adj + sp.eye(adj.shape[0]))\n \n \n adj = torch.FloatTensor(np.array(adj.todense()))\n features = torch.FloatTensor(np.array(features.todense()))\n labels = torch.LongTensor(np.where(labels)[1])\n\n idx_train = torch.LongTensor(idx_train)\n idx_val = torch.LongTensor(idx_val)\n idx_test = torch.LongTensor(idx_test)\n print(idx_train)\n return adj, features, labels, idx_train, idx_val, idx_test\n\n\ndef normalize_adj(mx):\n \"\"\"Row-normalize sparse matrix\"\"\"\n rowsum = np.array(mx.sum(1))\n r_inv_sqrt = np.power(rowsum, -0.5).flatten()\n r_inv_sqrt[np.isinf(r_inv_sqrt)] = 0.\n r_mat_inv_sqrt = sp.diags(r_inv_sqrt)\n return mx.dot(r_mat_inv_sqrt).transpose().dot(r_mat_inv_sqrt)\n\n\ndef normalize_features(mx):\n \"\"\"Row-normalize sparse matrix\"\"\"\n rowsum = np.array(mx.sum(1))\n r_inv = np.power(rowsum, -1).flatten()\n r_inv[np.isinf(r_inv)] = 0.\n r_mat_inv = sp.diags(r_inv)\n mx = r_mat_inv.dot(mx)\n return mx\n\n\ndef accuracy(output, labels):\n preds = output.max(1)[1].type_as(labels)\n correct = preds.eq(labels).double()\n correct = correct.sum()\n return correct / len(labels)\n\n"
] | [
[
"numpy.eye",
"numpy.ones",
"pandas.read_csv",
"numpy.dtype",
"numpy.isinf",
"scipy.sparse.csr_matrix",
"scipy.sparse.diags",
"scipy.sparse.eye",
"numpy.power",
"numpy.array",
"numpy.where",
"torch.LongTensor"
]
] |
wnorris/models | [
"a5e4965d1f4e4b02d51aa344336b6fff53af7c17"
] | [
"official/projects/yt8m/dataloaders/yt8m_input_test.py"
] | [
"# Copyright 2022 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\nimport os\n\nfrom absl import logging\nfrom absl.testing import parameterized\nimport numpy as np\nimport tensorflow as tf\n\nfrom official.core import input_reader\nfrom official.projects.yt8m.configs import yt8m as yt8m_configs\nfrom official.projects.yt8m.dataloaders import utils\nfrom official.projects.yt8m.dataloaders import yt8m_input\nfrom official.vision.dataloaders import tfexample_utils\n\n\nclass Yt8mInputTest(parameterized.TestCase, tf.test.TestCase):\n\n def setUp(self):\n super().setUp()\n self._model_dir = os.path.join(self.get_temp_dir(), 'model_dir')\n tf.io.gfile.makedirs(self._model_dir)\n\n data_dir = os.path.join(self.get_temp_dir(), 'data')\n tf.io.gfile.makedirs(data_dir)\n self.data_path = os.path.join(data_dir, 'data.tfrecord')\n self.num_segment = 6\n examples = [utils.MakeYt8mExample(self.num_segment) for _ in range(8)]\n tfexample_utils.dump_to_tfrecord(self.data_path, tf_examples=examples)\n\n def create_input_reader(self, params):\n decoder = yt8m_input.Decoder(input_params=params)\n decoder_fn = decoder.decode\n parser = yt8m_input.Parser(input_params=params)\n parser_fn = parser.parse_fn(params.is_training)\n postprocess = yt8m_input.PostBatchProcessor(input_params=params)\n postprocess_fn = postprocess.post_fn\n transform_batch = yt8m_input.TransformBatcher(input_params=params)\n batch_fn = transform_batch.batch_fn\n\n return input_reader.InputReader(\n params,\n dataset_fn=tf.data.TFRecordDataset,\n decoder_fn=decoder_fn,\n parser_fn=parser_fn,\n postprocess_fn=postprocess_fn,\n transform_and_batch_fn=batch_fn)\n\n @parameterized.parameters((True,), (False,))\n def test_read_video_level_input(self, include_video_id):\n params = yt8m_configs.yt8m(is_training=False)\n params.global_batch_size = 4\n params.segment_labels = False\n params.input_path = self.data_path\n params.include_video_id = include_video_id\n reader = self.create_input_reader(params)\n\n dataset = reader.read()\n iterator = iter(dataset)\n example = next(iterator)\n\n for k, v in example.items():\n logging.info('DEBUG read example %r %r %r', k, v.shape, type(v))\n if include_video_id:\n self.assertCountEqual(\n ['video_matrix', 'labels', 'num_frames', 'video_ids'], example.keys())\n else:\n self.assertCountEqual(['video_matrix', 'labels', 'num_frames'],\n example.keys())\n batch_size = params.global_batch_size\n self.assertEqual(\n example['video_matrix'].shape.as_list(),\n [batch_size, params.max_frames, sum(params.feature_sizes)])\n self.assertEqual(example['labels'].shape.as_list(),\n [batch_size, params.num_classes])\n self.assertEqual(example['num_frames'].shape.as_list(), [batch_size, 1])\n if include_video_id:\n self.assertEqual(example['video_ids'].shape.as_list(), [batch_size, 1])\n\n @parameterized.parameters((True,), (False,))\n def test_read_segement_level_input(self, include_video_id):\n params = yt8m_configs.yt8m(is_training=False)\n params.global_batch_size = 4\n params.segment_labels = True\n params.input_path = self.data_path\n params.include_video_id = include_video_id\n reader = self.create_input_reader(params)\n\n dataset = reader.read()\n iterator = iter(dataset)\n example = next(iterator)\n\n for k, v in example.items():\n logging.info('DEBUG read example %r %r %r', k, v.shape, type(v))\n if include_video_id:\n self.assertCountEqual([\n 'video_matrix', 'labels', 'num_frames', 'label_weights', 'video_ids'\n ], example.keys())\n else:\n self.assertCountEqual(\n ['video_matrix', 'labels', 'num_frames', 'label_weights'],\n example.keys())\n batch_size = params.global_batch_size * self.num_segment\n self.assertEqual(\n example['video_matrix'].shape.as_list(),\n [batch_size, params.segment_size, sum(params.feature_sizes)])\n self.assertEqual(example['labels'].shape.as_list(),\n [batch_size, params.num_classes])\n self.assertEqual(example['num_frames'].shape.as_list(), [batch_size, 1])\n self.assertEqual(example['label_weights'].shape.as_list(),\n [batch_size, params.num_classes])\n if include_video_id:\n self.assertEqual(example['video_ids'].shape.as_list(), [batch_size])\n\n @parameterized.parameters((True,), (False,))\n def test_read_video_level_float_input(self, include_video_id):\n data_dir = os.path.join(self.get_temp_dir(), 'data2')\n tf.io.gfile.makedirs(data_dir)\n data_path = os.path.join(data_dir, 'data2.tfrecord')\n examples = [\n utils.MakeExampleWithFloatFeatures(self.num_segment) for _ in range(8)\n ]\n tfexample_utils.dump_to_tfrecord(data_path, tf_examples=examples)\n\n params = yt8m_configs.yt8m(is_training=False)\n params.global_batch_size = 4\n params.segment_labels = False\n params.input_path = data_path\n params.num_frames = 2\n params.max_frames = 2\n params.feature_names = ('VIDEO_EMBEDDING/context_feature/floats',\n 'FEATURE/feature/floats')\n params.feature_sources = ('context', 'feature')\n params.feature_dtypes = ('float32', 'float32')\n params.feature_sizes = (256, 2048)\n params.feature_from_bytes = (False, False)\n params.include_video_id = include_video_id\n reader = self.create_input_reader(params)\n\n dataset = reader.read()\n iterator = iter(dataset)\n example = next(iterator)\n\n for k, v in example.items():\n logging.info('DEBUG read example %r %r %r', k, v.shape, type(v))\n logging.info('DEBUG read example %r', example['video_matrix'][0, 0, :])\n if include_video_id:\n self.assertCountEqual(\n ['video_matrix', 'labels', 'num_frames', 'video_ids'], example.keys())\n else:\n self.assertCountEqual(['video_matrix', 'labels', 'num_frames'],\n example.keys())\n\n # Check tensor values.\n expected_context = examples[0].context.feature[\n 'VIDEO_EMBEDDING/context_feature/floats'].float_list.value\n expected_feature = examples[0].feature_lists.feature_list[\n 'FEATURE/feature/floats'].feature[0].float_list.value\n expected_labels = examples[0].context.feature[\n params.label_field].int64_list.value\n self.assertAllEqual(\n expected_feature,\n example['video_matrix'][0, 0, params.feature_sizes[0]:])\n self.assertAllEqual(\n expected_context,\n example['video_matrix'][0, 0, :params.feature_sizes[0]])\n self.assertAllEqual(\n np.nonzero(example['labels'][0, :].numpy())[0], expected_labels)\n\n # Check tensor shape.\n batch_size = params.global_batch_size\n self.assertEqual(\n example['video_matrix'].shape.as_list(),\n [batch_size, params.max_frames, sum(params.feature_sizes)])\n self.assertEqual(example['labels'].shape.as_list(),\n [batch_size, params.num_classes])\n self.assertEqual(example['num_frames'].shape.as_list(), [batch_size, 1])\n if include_video_id:\n self.assertEqual(example['video_ids'].shape.as_list(), [batch_size, 1])\n\nif __name__ == '__main__':\n tf.test.main()\n"
] | [
[
"tensorflow.io.gfile.makedirs",
"tensorflow.test.main"
]
] |
ruoxinx/site-dust-detect | [
"f1b4c71f3ce5c325b25e26e9d663e3c1f7096ce7"
] | [
"demo/yolo.py"
] | [
"import colorsys\nimport os\n\nimport numpy as np\nfrom keras import backend as K\nfrom keras.layers import Input\nfrom keras.models import load_model\nfrom PIL import Image, ImageDraw, ImageFont\n\nfrom nets.yolo3 import yolo_body, yolo_eval\nfrom utils.utils import letterbox_image\n\nclass YOLO(object):\n _defaults = {\n \"model_path\" : '../model/trained_weights.h5',\n \"anchors_path\" : '../model/yolo_anchors.txt',\n \"classes_path\" : '../model/yolo_classes.txt',\n \"score\" : 0.5,\n \"iou\" : 0.3,\n \"max_boxes\" : 100,\n \"model_image_size\" : (416, 416),\n \"letterbox_image\" : False,\n }\n\n def get_defaults(cls, n):\n if n in cls._defaults:\n return cls._defaults[n]\n else:\n return \"Unrecognized attribute name '\" + n + \"'\"\n\n def __init__(self, **kwargs):\n self.__dict__.update(self._defaults)\n self.class_names = self._get_class()\n self.anchors = self._get_anchors()\n self.sess = K.get_session()\n self.boxes, self.scores, self.classes = self.generate()\n\n def _get_class(self):\n classes_path = os.path.expanduser(self.classes_path)\n with open(classes_path) as f:\n class_names = f.readlines()\n class_names = [c.strip() for c in class_names]\n return class_names\n\n def _get_anchors(self):\n anchors_path = os.path.expanduser(self.anchors_path)\n with open(anchors_path) as f:\n anchors = f.readline()\n anchors = [float(x) for x in anchors.split(',')]\n return np.array(anchors).reshape(-1, 2)\n\n def generate(self):\n model_path = os.path.expanduser(self.model_path)\n assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'\n\n num_anchors = len(self.anchors)\n num_classes = len(self.class_names)\n\n try:\n self.yolo_model = load_model(model_path, compile=False)\n except:\n self.yolo_model = yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)\n self.yolo_model.load_weights(self.model_path)\n else:\n assert self.yolo_model.layers[-1].output_shape[-1] == \\\n num_anchors/len(self.yolo_model.output) * (num_classes + 5), \\\n 'Mismatch between model and given anchor and class sizes'\n\n hsv_tuples = [(x / len(self.class_names), 1., 1.)\n for x in range(len(self.class_names))]\n self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))\n self.colors = list(\n map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),\n self.colors))\n\n np.random.seed(10101)\n np.random.shuffle(self.colors)\n np.random.seed(None)\n\n self.input_image_shape = K.placeholder(shape=(2, ))\n\n boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,\n num_classes, self.input_image_shape, max_boxes = self.max_boxes,\n score_threshold = self.score, iou_threshold = self.iou, letterbox_image = self.letterbox_image)\n return boxes, scores, classes\n\n def detect_image(self, image):\n if self.letterbox_image:\n boxed_image = letterbox_image(image, (self.model_image_size[1],self.model_image_size[0]))\n else:\n boxed_image = image.convert('RGB')\n boxed_image = boxed_image.resize((self.model_image_size[1],self.model_image_size[0]), Image.BICUBIC)\n image_data = np.array(boxed_image, dtype='float32')\n image_data /= 255.\n image_data = np.expand_dims(image_data, 0)\n out_boxes, out_scores, out_classes = self.sess.run(\n [self.boxes, self.scores, self.classes],\n feed_dict={\n self.yolo_model.input: image_data,\n self.input_image_shape: [image.size[1], image.size[0]],\n K.learning_phase(): 0})\n\n font = ImageFont.truetype(font='simhei.ttf',\n size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))\n thickness = max((image.size[0] + image.size[1]) // 300, 1)\n\n for i, c in list(enumerate(out_classes)):\n predicted_class = self.class_names[c]\n box = out_boxes[i]\n score = out_scores[i]\n\n top, left, bottom, right = box\n top = top - 5\n left = left - 5\n bottom = bottom + 5\n right = right + 5\n\n top = max(0, np.floor(top + 0.5).astype('int32'))\n left = max(0, np.floor(left + 0.5).astype('int32'))\n bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))\n right = min(image.size[0], np.floor(right + 0.5).astype('int32'))\n\n label = '{} {:.2f}'.format(predicted_class, score)\n draw = ImageDraw.Draw(image)\n label_size = draw.textsize(label, font)\n label = label.encode('utf-8')\n print(label, top, left, bottom, right)\n \n if top - label_size[1] >= 0:\n text_origin = np.array([left, top - label_size[1]])\n else:\n text_origin = np.array([left, top + 1])\n\n for i in range(thickness):\n draw.rectangle(\n [left + i, top + i, right - i, bottom - i],\n outline=self.colors[c])\n draw.rectangle(\n [tuple(text_origin), tuple(text_origin + label_size)],\n fill=self.colors[c])\n draw.text(text_origin, str(label,'UTF-8'), fill=(0, 0, 0), font=font)\n del draw\n\n return image\n\n def close_session(self):\n self.sess.close()\n"
] | [
[
"numpy.random.shuffle",
"numpy.floor",
"numpy.random.seed",
"numpy.expand_dims",
"numpy.array"
]
] |
MuawizChaudhary/STARTUP | [
"5cfa6694a4ffa6ffd3cc22deceb4626fd008ee83"
] | [
"teacher_miniImageNet/datasets/cifar_few_shot.py"
] | [
"# This code is modified from https://github.com/facebookresearch/low-shot-shrink-hallucinate\n\nimport torch\nfrom PIL import Image\nimport numpy as np\nimport torchvision.transforms as transforms\nimport additional_transforms as add_transforms\nfrom abc import abstractmethod\nfrom torchvision.datasets import CIFAR100, CIFAR10\n\nidentity = lambda x:x\nclass SimpleDataset:\n def __init__(self, mode, dataset, transform, target_transform=identity):\n self.transform = transform\n self.dataset = dataset\n self.target_transform = target_transform\n\n self.meta = {}\n\n self.meta['image_names'] = []\n self.meta['image_labels'] = []\n if self.dataset == \"CIFAR100\":\n\n d = CIFAR100(\"./\", train=True, download=True)\n for i, (data, label) in enumerate(d):\n if mode == \"base\":\n if label % 3 == 0:\n self.meta['image_names'].append(data)\n self.meta['image_labels'].append(label)\n elif mode == \"val\":\n if label % 3 == 1:\n self.meta['image_names'].append(data)\n self.meta['image_labels'].append(label) \n else:\n if label % 3 == 2:\n self.meta['image_names'].append(data)\n self.meta['image_labels'].append(label) \n\n elif self.dataset == \"CIFAR10\":\n d = CIFAR10(\"./\", train=True, download=True)\n for i, (data, label) in enumerate(d):\n if mode == \"novel\":\n self.meta['image_names'].append(data)\n self.meta['image_labels'].append(label) \n\n def __getitem__(self, i):\n\n img = self.transform(self.meta['image_names'][i])\n target = self.target_transform(self.meta['image_labels'][i])\n\n return img, target\n\n def __len__(self):\n return len(self.meta['image_names'])\n\n\nclass SetDataset:\n def __init__(self, mode, dataset, batch_size, transform):\n\n self.sub_meta = {}\n self.cl_list = range(100)\n self.dataset = dataset\n\n if mode == \"base\":\n type_ = 0\n elif mode == \"val\":\n type_ = 1\n else:\n type_ = 2\n\n for cl in self.cl_list:\n if cl % 3 == type_:\n self.sub_meta[cl] = []\n\n if self.dataset == \"CIFAR100\":\n d = CIFAR100(\"./\", train=True, download=True)\n elif self.dataset == \"CIFAR10\":\n d = CIFAR10(\"./\", train=True, download=True)\n\n\n for i, (data, label) in enumerate(d):\n if label % 3 == type_:\n self.sub_meta[label].append(data)\n \n self.sub_dataloader = [] \n sub_data_loader_params = dict(batch_size = batch_size,\n shuffle = True,\n num_workers = 0, #use main thread only or may receive multiple batches\n pin_memory = False) \n for cl in self.cl_list:\n if cl % 3 == type_:\n sub_dataset = SubDataset(self.sub_meta[cl], cl, transform = transform )\n self.sub_dataloader.append( torch.utils.data.DataLoader(sub_dataset, **sub_data_loader_params) )\n\n def __getitem__(self,i):\n return next(iter(self.sub_dataloader[i]))\n\n def __len__(self):\n return len(self.sub_dataloader)\n\nclass SubDataset:\n def __init__(self, sub_meta, cl, transform=transforms.ToTensor(), target_transform=identity):\n self.sub_meta = sub_meta\n self.cl = cl \n self.transform = transform\n self.target_transform = target_transform\n\n def __getitem__(self,i):\n\n img = self.transform(self.sub_meta[i])\n target = self.target_transform(self.cl)\n return img, target\n\n def __len__(self):\n return len(self.sub_meta)\n\nclass EpisodicBatchSampler(object):\n def __init__(self, n_classes, n_way, n_episodes):\n self.n_classes = n_classes\n self.n_way = n_way\n self.n_episodes = n_episodes\n\n def __len__(self):\n return self.n_episodes\n\n def __iter__(self):\n for i in range(self.n_episodes):\n yield torch.randperm(self.n_classes)[:self.n_way]\n\nclass TransformLoader:\n def __init__(self, image_size, \n normalize_param = dict(mean= [0.485, 0.456, 0.406] , std=[0.229, 0.224, 0.225]),\n jitter_param = dict(Brightness=0.4, Contrast=0.4, Color=0.4)):\n self.image_size = image_size\n self.normalize_param = normalize_param\n self.jitter_param = jitter_param\n \n def parse_transform(self, transform_type):\n if transform_type=='ImageJitter':\n method = add_transforms.ImageJitter( self.jitter_param )\n return method\n method = getattr(transforms, transform_type)\n if transform_type=='RandomSizedCrop':\n return method(self.image_size) \n elif transform_type=='CenterCrop':\n return method(self.image_size) \n elif transform_type=='Scale':\n return method([int(self.image_size*1.15), int(self.image_size*1.15)])\n elif transform_type=='Normalize':\n return method(**self.normalize_param )\n else:\n return method()\n\n def get_composed_transform(self, aug = False):\n if aug:\n transform_list = ['RandomSizedCrop', 'ImageJitter', 'RandomHorizontalFlip', 'ToTensor', 'Normalize']\n else:\n transform_list = ['Scale','CenterCrop', 'ToTensor', 'Normalize']\n\n transform_funcs = [ self.parse_transform(x) for x in transform_list]\n transform = transforms.Compose(transform_funcs)\n return transform\n\nclass DataManager(object):\n @abstractmethod\n def get_data_loader(self, data_file, aug):\n pass \n\nclass SimpleDataManager(DataManager):\n def __init__(self, dataset, image_size, batch_size): \n super(SimpleDataManager, self).__init__()\n self.batch_size = batch_size\n self.trans_loader = TransformLoader(image_size)\n self.dataset = dataset\n\n def get_data_loader(self, mode, aug): #parameters that would change on train/val set\n transform = self.trans_loader.get_composed_transform(aug)\n dataset = SimpleDataset(mode, self.dataset, transform)\n\n data_loader_params = dict(batch_size = self.batch_size, shuffle = True, num_workers = 12, pin_memory = True) \n data_loader = torch.utils.data.DataLoader(dataset, **data_loader_params)\n\n return data_loader\n\nclass SetDataManager(DataManager):\n def __init__(self, mode, dataset, image_size, n_way=5, n_support=5, n_query=16, n_eposide = 100): \n super(SetDataManager, self).__init__()\n self.image_size = image_size\n self.n_way = n_way\n self.batch_size = n_support + n_query\n self.n_eposide = n_eposide\n self.mode = mode\n self.dataset = dataset\n\n self.trans_loader = TransformLoader(image_size)\n\n def get_data_loader(self, aug): #parameters that would change on train/val set\n transform = self.trans_loader.get_composed_transform(aug)\n dataset = SetDataset(self.mode, self.dataset, self.batch_size, transform)\n sampler = EpisodicBatchSampler(len(dataset), self.n_way, self.n_eposide ) \n data_loader_params = dict(batch_sampler = sampler, num_workers = 12, pin_memory = True) \n data_loader = torch.utils.data.DataLoader(dataset, **data_loader_params)\n return data_loader\n\nif __name__ == '__main__':\n pass"
] | [
[
"torch.utils.data.DataLoader",
"torch.randperm"
]
] |
thadanipaarth/Non-Invasive-Public-Safety-Detection-System | [
"760b79c295e31003c7d0e826fe9214a73245c344"
] | [
"Scripts/training_mask_detection_model.py"
] | [
"from tensorflow.keras.preprocessing.image import ImageDataGenerator\nfrom tensorflow.keras.applications import MobileNetV2\nfrom tensorflow.keras.layers import AveragePooling2D\nfrom tensorflow.keras.layers import Dropout\nfrom tensorflow.keras.layers import Flatten\nfrom tensorflow.keras.layers import Dense\nfrom tensorflow.keras.layers import Input\nfrom tensorflow.keras.models import Model\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.applications.mobilenet_v2 import preprocess_input\nfrom tensorflow.keras.preprocessing.image import img_to_array\nfrom tensorflow.keras.preprocessing.image import load_img\nfrom tensorflow.keras.utils import to_categorical\nfrom sklearn.preprocessing import LabelBinarizer\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import classification_report\nfrom imutils import paths\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport argparse\nimport os\n\nINIT_LR = 1e-4\nEPOCHS = 20\nBS = 32\nimagePaths = list(paths.list_images('./Mask_Detection_Dataset/'))\ndata = []\nlabels = []\nfor imagePath in imagePaths:\n\tlabel = imagePath.split(os.path.sep)[-2]\n\timage = load_img(imagePath, target_size=(224, 224))\n\timage = img_to_array(image)\n\timage = preprocess_input(image)\n\tdata.append(image)\n\tlabels.append(label)\ndata = np.array(data, dtype=\"float32\")\nlabels = np.array(labels)\nlb = LabelBinarizer()\nlabels = lb.fit_transform(labels)\nlabels = to_categorical(labels)\n(trainX, testX, trainY, testY) = train_test_split(data, labels,\n\ttest_size=0.20, stratify=labels, random_state=42)\naug = ImageDataGenerator(\n\trotation_range=20,\n\tzoom_range=0.15,\n\twidth_shift_range=0.2,\n\theight_shift_range=0.2,\n\tshear_range=0.15,\n\thorizontal_flip=True,\n\tfill_mode=\"nearest\")\nbaseModel = MobileNetV2(weights=\"imagenet\", include_top=False,\n\tinput_tensor=Input(shape=(224, 224, 3)))\nheadModel = baseModel.output\nheadModel = AveragePooling2D(pool_size=(7, 7))(headModel)\nheadModel = Flatten(name=\"flatten\")(headModel)\nheadModel = Dense(128, activation=\"relu\")(headModel)\nheadModel = Dropout(0.5)(headModel)\nheadModel = Dense(2, activation=\"softmax\")(headModel)\nmodel = Model(inputs=baseModel.input, outputs=headModel)\nfor layer in baseModel.layers:\n\tlayer.trainable = False\nopt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)\nmodel.compile(loss=\"binary_crossentropy\", optimizer=opt,\n\tmetrics=[\"accuracy\"])\nH = model.fit(\n\taug.flow(trainX, trainY, batch_size=BS),\n\tsteps_per_epoch=len(trainX) // BS,\n\tvalidation_data=(testX, testY),\n\tvalidation_steps=len(testX) // BS,\n\tepochs=EPOCHS)\npredIdxs = model.predict(testX, batch_size=BS)\npredIdxs = np.argmax(predIdxs, axis=1)\nprint(classification_report(testY.argmax(axis=1), predIdxs,\n\ttarget_names=lb.classes_))\nmodel.save('mask_model', save_format=\"h5\")\n"
] | [
[
"sklearn.preprocessing.LabelBinarizer",
"tensorflow.keras.utils.to_categorical",
"tensorflow.keras.optimizers.Adam",
"tensorflow.keras.layers.Flatten",
"tensorflow.keras.layers.Dropout",
"tensorflow.keras.applications.mobilenet_v2.preprocess_input",
"tensorflow.keras.preprocessing.image.ImageDataGenerator",
"tensorflow.keras.preprocessing.image.load_img",
"tensorflow.keras.preprocessing.image.img_to_array",
"numpy.argmax",
"tensorflow.keras.models.Model",
"tensorflow.keras.layers.Dense",
"numpy.array",
"tensorflow.keras.layers.AveragePooling2D",
"sklearn.model_selection.train_test_split",
"tensorflow.keras.layers.Input"
]
] |
jaywilhelm/OpenUxAS | [
"76b08d94c4c51ca51d9f79c9db03d7344e9d6552"
] | [
"examples/02_Example_WaterwaySearch/dubinsUAV.py"
] | [
"from matplotlib import pyplot as plt\nfrom shapely.geometry import Point\nfrom shapely.geometry.polygon import Polygon\n#from lineSegmentAoE import *\nimport numpy as np\nimport sys\n\nclass dubinsUAV():\n\n def __init__(self, position, velocity, heading, dt=0.1):\n\n self.velocity = velocity\n self.turnRateLimited = True\n self.v = velocity\n self.dt = dt\n self.t = 0\n self.turnrate = np.deg2rad(20)\n #self.turn_radius = []\n\n\n #Current state\n self.x = position[0]\n self.y = position[1]\n self.vx = []\n self.vy = []\n self.lastDist = np.inf\n #self.cmdHeading = []\n #self.flightEnvX = []\n #self.flightEnvY = []\n \n self.heading = heading\n self.currentWPIndex = 0\n self.withinThreshold = False\n\n # History\n self.xs = np.array([])\n self.ys = np.array([])\n self.vxs = np.array([])\n self.vys = np.array([])\n self.headings = np.array([])\n #self.headingcmds = np.array([])\n self.ts = np.array([])\n\n self.vx = velocity * np.cos(heading)\n self.vy = velocity * np.sin(heading)\n self.dt = dt\n #self.turn_radius = self.v / self.turnrate\n def getPosition(self):\n return [self.position[0], self.position[1]]\n\n def setWaypoints(self, newwps, newradius=0.01):\n self.waypoints = newwps\n self.wpRadius = newradius\n\n def getWaypoints(self):\n return self.waypoints\n \n def getActiveWaypoint(self):\n return self.waypoints[self.currentWPIndex]\n\n def simulateWPDubins(self):\n # currentWPIndex = 0\n # withinThreshold = False\n # lastDist = sys.maxsize\n wpRadius = self.wpRadius\n activeWP = self.getActiveWaypoint()\n dist = self.distance(activeWP, (self.x, self.y))\n\n print('D: ' + str(dist) + '\\t ' + str(dist < wpRadius) + '\\t ' + str(dist > self.lastDist) + '\\t# ' + str(self.currentWPIndex) + '\\tLast: ' + str(self.lastDist))\n\n\n if (dist < wpRadius and dist > self.lastDist):\n if(self.currentWPIndex < len(self.waypoints)-1):\n self.currentWPIndex += 1\n print(\"WP Increment\")\n #update distance...\n dist = self.distance(self.getActiveWaypoint(), (self.x, self.y))\n else:\n print(\"end of list, do something\")\n\n RHeading = np.arctan2(self.y - activeWP[1], self.x - activeWP[0])\n RHeading += np.deg2rad(180)\n if(RHeading >= np.pi*2):\n RHeading -= np.pi*2\n self.update_pos(RHeading)\n\n self.lastDist = dist\n\n def distance(self, a, b):\n return np.sqrt((a[0] - b[0])**2 + (a[1] - b[1])**2)\n\n\n def update_pos(self, RequestedHeading):\n\n if self.turnRateLimited:\n theta = self.heading \n if(np.abs(RequestedHeading - theta) < self.turnrate * self.dt):\n turnrate = np.abs(RequestedHeading - theta) / self.dt\n else:\n turnrate = self.turnrate\n\n if abs(theta - RequestedHeading) < np.pi:\n if theta - RequestedHeading < 0:\n theta = theta + turnrate * self.dt\n else:\n theta = theta - turnrate * self.dt\n\n else:\n if theta - RequestedHeading > 0:\n theta = theta + turnrate * self.dt\n else:\n theta = theta - turnrate * self.dt\n # if(np.abs(RequestedHeading - theta) > self.turnrate * self.dt):\n # if theta - RequestedHeading < 0:\n # theta = theta + self.turnrate * self.dt\n # else:\n # theta = theta - self.turnrate * self.dt\n # else:\n # theta = RequestedHeading\n else:\n theta = RequestedHeading\n if(theta >= np.pi*2):\n theta -= np.pi*2\n print('Req: '+ str(np.rad2deg(RequestedHeading)) + '\\ttheta ' + str(np.rad2deg(theta)))\n # Update States\n self.t = self.t + self.dt\n self.heading = theta\n #self.cmdHeading = VF_heading\n self.update_pos_simple()\n\n def update_pos_simple(self):\n # Update States\n self.t = self.t + self.dt\n theta = self.heading\n self.vx = self.v * np.cos(theta)\n self.vy = self.v * np.sin(theta)\n self.x = self.x + self.vx * self.dt\n self.y = self.y + self.vy * self.dt\n self.position = [(self.x, self.y)] # added for CAS\n\n # Update History\n self.xs = np.append(self.xs, self.x)\n self.ys = np.append(self.ys, self.y)\n self.vxs = np.append(self.vxs, self.vx)\n self.vys = np.append(self.vys, self.vy)\n self.headings = np.append(self.headings, self.heading)\n self.ts = np.append(self.ts, self.t)\n\n"
] | [
[
"numpy.sqrt",
"numpy.arctan2",
"numpy.append",
"numpy.rad2deg",
"numpy.abs",
"numpy.cos",
"numpy.array",
"numpy.sin",
"numpy.deg2rad"
]
] |
lucifer2859/sac-discrete-pytorch | [
"c6f367d95bdc5cee8b3d6e5a01172bb99af5b171"
] | [
"sacd/agent/sacd.py"
] | [
"import os\nimport numpy as np\nimport torch\nfrom torch.optim import Adam\n\nfrom .base import BaseAgent\nfrom sacd.model import TwinnedQNetwork, CategoricalPolicy\nfrom sacd.utils import disable_gradients\n\n# If you want to use Prioritized Experience Replay(PER), N-step return \n# or Dueling Networks, change use_per, multi_step or dueling_net respectively.\n\nclass SacdAgent(BaseAgent):\n\n def __init__(self, env, test_env, log_dir, num_steps=100000, batch_size=64,\n lr=0.0003, memory_size=1000000, gamma=0.99, multi_step=1,\n target_entropy_ratio=0.98, start_steps=20000,\n update_interval=4, target_update_interval=8000,\n use_per=False, dueling_net=False, num_eval_steps=125000,\n max_episode_steps=27000, log_interval=10, eval_interval=1000,\n device='cuda:0', seed=0):\n\n super().__init__(\n env, test_env, log_dir, num_steps, batch_size, memory_size, gamma,\n multi_step, target_entropy_ratio, start_steps, update_interval,\n target_update_interval, use_per, num_eval_steps, max_episode_steps,\n log_interval, eval_interval, device, seed)\n\n # Define networks.\n self.policy = CategoricalPolicy(\n self.env.observation_space.shape[0], self.env.action_space.n\n ).to(self.device)\n\n self.online_critic = TwinnedQNetwork(\n self.env.observation_space.shape[0], self.env.action_space.n,\n dueling_net=dueling_net).to(device=self.device)\n\n self.target_critic = TwinnedQNetwork(\n self.env.observation_space.shape[0], self.env.action_space.n,\n dueling_net=dueling_net).to(device=self.device).eval()\n\n # Copy parameters of the learning network to the target network.\n self.target_critic.load_state_dict(self.online_critic.state_dict())\n\n # Disable gradient calculations of the target network.\n disable_gradients(self.target_critic)\n\n self.policy_optim = Adam(self.policy.parameters(), lr=lr)\n self.q1_optim = Adam(self.online_critic.Q1.parameters(), lr=lr)\n self.q2_optim = Adam(self.online_critic.Q2.parameters(), lr=lr)\n\n # Target entropy is -log(1/|A|) * ratio (= maximum entropy * ratio).\n self.target_entropy = \\\n -np.log(1.0 / self.env.action_space.n) * target_entropy_ratio\n\n # We optimize log(alpha), instead of alpha.\n self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\n self.alpha = self.log_alpha.exp()\n self.alpha_optim = Adam([self.log_alpha], lr=lr)\n\n def explore(self, state):\n # Act with randomness.\n state = torch.ByteTensor(\n state[None, ...]).to(self.device).float() / 255.\n with torch.no_grad():\n action, _, _ = self.policy.sample(state)\n return action.item()\n\n def exploit(self, state):\n # Act without randomness.\n state = torch.ByteTensor(\n state[None, ...]).to(self.device).float() / 255.\n with torch.no_grad():\n action = self.policy.act(state)\n return action.item()\n\n def update_target(self):\n self.target_critic.load_state_dict(self.online_critic.state_dict())\n\n def calc_current_q(self, states, actions, rewards, next_states, dones):\n curr_q1, curr_q2 = self.online_critic(states)\n curr_q1 = curr_q1.gather(1, actions.long())\n curr_q2 = curr_q2.gather(1, actions.long())\n return curr_q1, curr_q2\n\n def calc_target_q(self, states, actions, rewards, next_states, dones):\n with torch.no_grad():\n _, action_probs, log_action_probs = self.policy.sample(next_states)\n next_q1, next_q2 = self.target_critic(next_states)\n next_q = (action_probs * (\n torch.min(next_q1, next_q2) - self.alpha * log_action_probs\n )).sum(dim=1, keepdim=True)\n\n assert rewards.shape == next_q.shape\n return rewards + (1.0 - dones) * self.gamma_n * next_q\n\n def calc_critic_loss(self, batch, weights):\n curr_q1, curr_q2 = self.calc_current_q(*batch)\n target_q = self.calc_target_q(*batch)\n\n # TD errors for updating priority weights\n errors = torch.abs(curr_q1.detach() - target_q)\n\n # We log means of Q to monitor training.\n mean_q1 = curr_q1.detach().mean().item()\n mean_q2 = curr_q2.detach().mean().item()\n\n # Critic loss is mean squared TD errors with priority weights.\n q1_loss = torch.mean((curr_q1 - target_q).pow(2) * weights)\n q2_loss = torch.mean((curr_q2 - target_q).pow(2) * weights)\n\n return q1_loss, q2_loss, errors, mean_q1, mean_q2\n\n def calc_policy_loss(self, batch, weights):\n states, actions, rewards, next_states, dones = batch\n\n # (Log of) probabilities to calculate expectations of Q and entropies.\n _, action_probs, log_action_probs = self.policy.sample(states)\n\n with torch.no_grad():\n # Q for every actions to calculate expectations of Q.\n q1, q2 = self.online_critic(states)\n q = torch.min(q1, q2)\n\n # Expectations of entropies.\n entropies = -torch.sum(\n action_probs * log_action_probs, dim=1, keepdim=True)\n\n # Expectations of Q.\n q = torch.sum(torch.min(q1, q2) * action_probs, dim=1, keepdim=True)\n\n # Policy objective is maximization of (Q + alpha * entropy) with\n # priority weights.\n policy_loss = (weights * (- q - self.alpha * entropies)).mean()\n\n return policy_loss, entropies.detach()\n\n def calc_entropy_loss(self, entropies, weights):\n assert not entropies.requires_grad\n\n # Intuitively, we increse alpha when entropy is less than target\n # entropy, vice versa.\n entropy_loss = -torch.mean(\n self.log_alpha * (self.target_entropy - entropies)\n * weights)\n return entropy_loss\n\n def save_models(self, save_dir):\n super().save_models(save_dir)\n self.policy.save(os.path.join(save_dir, 'policy.pth'))\n self.online_critic.save(os.path.join(save_dir, 'online_critic.pth'))\n self.target_critic.save(os.path.join(save_dir, 'target_critic.pth'))\n"
] | [
[
"torch.sum",
"torch.min",
"torch.no_grad",
"torch.optim.Adam",
"torch.ByteTensor",
"numpy.log",
"torch.zeros",
"torch.mean"
]
] |
freenowill/autoVC-WavRNN | [
"871a7ae5671e81fe4396cbc6f89a90009b01049b"
] | [
"vocoder/inference_wavrnn.py"
] | [
"from vocoder.models.fatchord_version import WaveRNN\r\nfrom vocoder import hparams as hp\r\nimport torch\r\n\r\n\r\n_model = None # type: WaveRNN\r\n\r\ndef load_model(weights_fpath, verbose=True):\r\n global _model\r\n \r\n if verbose:\r\n print(\"Building Wave-RNN\")\r\n _model = WaveRNN(\r\n rnn_dims=hp.voc_rnn_dims,\r\n fc_dims=hp.voc_fc_dims,\r\n bits=hp.bits,\r\n pad=hp.voc_pad,\r\n upsample_factors=hp.voc_upsample_factors,\r\n feat_dims=hp.num_mels,\r\n compute_dims=hp.voc_compute_dims,\r\n res_out_dims=hp.voc_res_out_dims,\r\n res_blocks=hp.voc_res_blocks,\r\n hop_length=hp.hop_length,\r\n sample_rate=hp.sample_rate,\r\n mode=hp.voc_mode\r\n ).cuda()\r\n \r\n if verbose:\r\n print(\"Loading model weights at %s\" % weights_fpath)\r\n checkpoint = torch.load(weights_fpath)\r\n _model.load_state_dict(checkpoint['model_state'])\r\n _model.eval()\r\n\r\n\r\ndef is_loaded():\r\n return _model is not None\r\n\r\n\r\ndef infer_waveform(mel, normalize=True, batched=True, target=24000, overlap=1000,\r\n progress_callback=None):\r\n \"\"\"\r\n Infers the waveform of a mel spectrogram output by the synthesizer (the format must match \r\n that of the synthesizer!)\r\n \r\n :param normalize: \r\n :param batched: \r\n :param target: \r\n :param overlap: \r\n :return: \r\n \"\"\"\r\n if _model is None:\r\n raise Exception(\"Please load Wave-RNN in memory before using it\")\r\n \r\n if normalize:\r\n mel = mel / hp.mel_max_abs_value\r\n mel = torch.from_numpy(mel[None, ...])\r\n wav = _model.generate(mel, batched, target, overlap, hp.mu_law, progress_callback)\r\n return wav\r\n"
] | [
[
"torch.from_numpy",
"torch.load"
]
] |
Peyo-Supp/Master-Production-Planning-Algorithm | [
"c91bf9304bcf1ad7ecdf6729ee483a6e3de45a38"
] | [
"Discount_bracket_replenishment.py"
] | [
"import pandas as pd\nimport math as m\nimport numpy as np\n\n\"\"\"\nalgorithm that calculate the best alternative from supplier order bracket based on data provided.\n\n\"\"\"\n\n#input data here!\n# demand_in_cases =\n# order_cost =\n# cost_per_case =\n# bracket_cost = []\n# bracket_minimum = []\n# holding_rate =\n\nEOQ0 = np.sqrt((2*demand_in_cases*order_cost)/(cost_per_case*holding_rate))\nATCEOQ = demand_in_cases/EOQ0*order_cost + EOQ0/2*holding_rate*cost_per_case + demand_in_cases*cost_per_case\n\n#create a dataframe for the bracket_minimum)\nBM = np.array(bracket_minimum)\n\n\ndfBM = pd.DataFrame({'1':[BM[0]],'2':[BM[1]],'3':[BM[2]],'4':[BM[3]],'5':[BM[4]],'6':[BM[5]],'7':[BM[6]]}, index = [1])\n\n#compute EOQ for each bracket and put into its own dataframe\n\nBC = np.array(bracket_cost)\nBM = np.array(bracket_minimum)\n\nEOQ = np.sqrt((2*demand_in_cases*order_cost)/(BC*holding_rate))\n\nDfEOQ = pd.DataFrame({'1':[EOQ[0]],'2': [EOQ[1]],'3':[EOQ[2]],'4':[EOQ[3]],'5':[EOQ[4]],'6':[EOQ[5]],'6':[EOQ[6]]}, index =[1])\n\n\n#substrack the BM data frame with eoq dataframe to find which data is greater than 0\n\ncheck = (dfBM.sub(DfEOQ))\n\nc = np.array(check)\nprint(c)\n\ndef calc_atc(c,val):\n\n for i in c:\n if i<= val:\n print( 'a' )\n\n else:\n print('b')\nval = 0\ncalc_atc(c,val)\n\n\n\n\n\n"
] | [
[
"numpy.sqrt",
"pandas.DataFrame",
"numpy.array"
]
] |
teamcfe/AI-as-an-API | [
"a291fc0e6ec380139599a948f2efd58923c70784"
] | [
"app/ml.py"
] | [
"import json\nimport numpy as np\n\nfrom typing import Optional, List\nfrom pathlib import Path\nfrom dataclasses import dataclass # pip install dataclasses\n\nfrom tensorflow.keras.models import load_model\nfrom tensorflow.keras.preprocessing.sequence import pad_sequences\nfrom tensorflow.keras.preprocessing.text import tokenizer_from_json\n\nfrom . import encoders\n\n@dataclass\nclass AIModel:\n model_path: Path\n tokenizer_path: Optional[Path] = None\n metadata_path: Optional[Path] = None\n\n model = None\n tokenizer = None\n metadata = None\n\n def __post_init__(self):\n if self.model_path.exists():\n self.model = load_model(self.model_path) \n if self.tokenizer_path:\n if self.tokenizer_path.exists():\n if self.tokenizer_path.name.endswith(\"json\"): \n tokenizer_text = self.tokenizer_path.read_text()\n self.tokenizer = tokenizer_from_json(tokenizer_text)\n if self.metadata_path:\n if self.metadata_path.exists():\n if self.metadata_path.name.endswith(\"json\"): \n self.metadata = json.loads(self.metadata_path.read_text())\n\n \n def get_model(self):\n if not self.model:\n raise Exception(\"Model not implemeted\")\n return self.model\n \n def get_tokenizer(self):\n if not self.tokenizer:\n raise Exception(\"tokenizer not implemeted\")\n return self.tokenizer\n \n def get_metadata(self):\n if not self.metadata:\n raise Exception(\"metadata not implemeted\")\n return self.metadata\n\n def get_sequences_from_text(self, texts: List[str] ):\n tokenizer = self.get_tokenizer()\n sequences = tokenizer.texts_to_sequences(texts)\n return sequences\n\n def get_input_from_sequences(self, sequences):\n maxlen = self.get_metadata().get('max_sequence') or 280\n x_input = pad_sequences(sequences, maxlen=maxlen)\n return x_input\n\n def get_label_legend_inverted(self):\n legend = self.get_metadata().get('labels_legend_inverted') or {}\n if len(legend.keys()) != 2:\n raise Exception(\"You legend is incorrect\")\n return legend\n\n def get_label_pred(self, idx, val):\n legend = self.get_label_legend_inverted()\n return {\"label\": legend[str(idx)], \"confidence\": val}\n\n def get_top_pred_labled(self, preds):\n top_idx_val = np.argmax(preds)\n val = preds[top_idx_val]\n return self.get_label_pred(top_idx_val, val)\n\n def predict_text(self, query:str, include_top=True, encode_to_json=True):\n model = self.get_model()\n sequences = self.get_sequences_from_text([query])\n x_input = self.get_input_from_sequences(sequences)\n preds = model.predict(x_input)[0]\n labeled_preds = [self.get_label_pred(i, x) for i, x in enumerate(list(preds))]\n results = {\n \"predictions\": labeled_preds\n }\n if include_top:\n results['top'] = self.get_top_pred_labled(preds)\n if encode_to_json:\n results = encoders.encode_to_json(results, as_py=True)\n return results"
] | [
[
"tensorflow.keras.preprocessing.text.tokenizer_from_json",
"tensorflow.keras.models.load_model",
"tensorflow.keras.preprocessing.sequence.pad_sequences",
"numpy.argmax"
]
] |
31337mbf/MLAlgorithms | [
"3c8e16b8de3baf131395ae57edd479e59566a7c6"
] | [
"mla/rbm.py"
] | [
"# coding:utf-8\nimport logging\n\nimport numpy as np\nfrom scipy.special import expit\n\nfrom mla.base import BaseEstimator\nfrom mla.utils import batch_iterator\n\nnp.random.seed(9999)\nsigmoid = expit\n\n\"\"\"\nReferences:\nA Practical Guide to Training Restricted Boltzmann Machines https://www.cs.toronto.edu/~hinton/absps/guideTR.pdf\n\"\"\"\n\n\nclass RBM(BaseEstimator):\n y_required = False\n\n def __init__(self, n_hidden=128, learning_rate=0.1, batch_size=10, max_epochs=100):\n \"\"\"Bernoulli Restricted Boltzmann Machine (RBM)\n\n Parameters\n ----------\n\n n_hidden : int, default 128\n The number of hidden units.\n learning_rate : float, default 0.1\n batch_size : int, default 10\n max_epochs : int, default 100\n \"\"\"\n self.max_epochs = max_epochs\n self.batch_size = batch_size\n self.lr = learning_rate\n self.n_hidden = n_hidden\n\n def fit(self, X, y=None):\n self.n_visible = X.shape[1]\n self._init_weights()\n self._setup_input(X, y)\n self._train()\n\n def _init_weights(self):\n\n self.W = np.random.randn(self.n_visible, self.n_hidden) * 0.1\n\n # Bias for visible and hidden units\n self.bias_v = np.zeros(self.n_visible, dtype=np.float32)\n self.bias_h = np.zeros(self.n_hidden, dtype=np.float32)\n\n self.errors = []\n\n def _train(self):\n \"\"\"Use CD-1 training procedure, basically an exact inference for `positive_associations`,\n followed by a \"non burn-in\" block Gibbs Sampling for the `negative_associations`.\"\"\"\n\n for i in range(self.max_epochs):\n error = 0\n for batch in batch_iterator(self.X, batch_size=self.batch_size):\n positive_hidden = sigmoid(np.dot(batch, self.W) + self.bias_h)\n hidden_states = self._sample(positive_hidden) # sample hidden state h1\n positive_associations = np.dot(batch.T, positive_hidden)\n\n negative_visible = sigmoid(np.dot(hidden_states, self.W.T) + self.bias_v)\n negative_visible = self._sample(negative_visible) # use the sampled hidden state h1 to sample v1\n negative_hidden = sigmoid(np.dot(negative_visible, self.W) + self.bias_h)\n negative_associations = np.dot(negative_visible.T, negative_hidden)\n\n lr = self.lr / float(batch.shape[0])\n self.W += lr * ((positive_associations - negative_associations) / float(self.batch_size))\n self.bias_h += lr * (negative_hidden.sum(axis=0) - negative_associations.sum(axis=0))\n self.bias_v += lr * (np.asarray(batch.sum(axis=0)).squeeze() - negative_visible.sum(axis=0))\n\n error += np.sum((batch - negative_visible) ** 2)\n\n self.errors.append(error)\n logging.info(\"Iteration %s, error %s\" % (i, error))\n logging.debug(\"Weights: %s\" % self.W)\n logging.debug(\"Hidden bias: %s\" % self.bias_h)\n logging.debug(\"Visible bias: %s\" % self.bias_v)\n\n def _sample(self, X):\n return X > np.random.random_sample(size=X.shape)\n\n def _predict(self, X=None):\n return sigmoid(np.dot(X, self.W) + self.bias_h)\n"
] | [
[
"numpy.random.random_sample",
"numpy.sum",
"numpy.zeros",
"numpy.random.randn",
"numpy.random.seed",
"numpy.dot"
]
] |
kurtmaia/JointSBM | [
"516daa6249694118cca4db2a4a92e0ef7164166f"
] | [
"jointSBM.py"
] | [
"import numpy as np \nimport scipy as sp\n\nfrom numpy.linalg import inv, cholesky\nfrom scipy.linalg import eig\nfrom sklearn.metrics.cluster import normalized_mutual_info_score as nmi\nfrom sklearn.metrics.cluster import adjusted_rand_score as ari\nfrom sklearn.metrics.cluster import contingency_matrix\nfrom sklearn.cluster import KMeans\nimport random\n\nimport time\nfrom joblib import Parallel, delayed\nimport multiprocessing\nfrom tqdm import tqdm\nimport logging\n\nfrom utils.utils import *\n\n\n\ndef update_W(X,Q,deltas_,K):\n delta2_n, delta2, gamma_n = deltas_\n\n XnQn = []\n XXn = []\n for i in range(len(Q)):\n rt = np.sum(delta2)/np.sum(delta2_n[i])\n XnQn.append(np.matmul(X[i].T,Q[i]*gamma_n[i]))\n XXn.append(delta2_n[i]*gamma_n[i])\n XQ = np.sum(XnQn,axis = 0) \n denom = np.sum(XXn,axis = 0)\n\n W = np.matmul(inv(denom),XQ)\n return W\n\ndef update_xni(q,W,rt,fac,gamman,K):\n dif = W - q\n term2 = ((q*np.sqrt(fac) + q*1./np.sqrt(rt))**2).sum(axis = 1)\n dist = np.diag(np.matmul(dif,dif.T))*gamman + term2\n x = onehot_vec(np.argmin(dist),K)\n return x\n\ndef get_fac(Vn,V,K):\n x = np.eye(K) \n fac = np.nan_to_num([[(Vn - x[i,:] + x[k,:])/(V - x[i,:] + x[k,:]) for k in range(K)] for i in range(K)])\n # fac[fac<0] = 0\n gamman = fac.sum(axis=2)\n return fac, gamman\n\ndef processLoop(Qn,W,Xn,V,deltas2_n,K):\n Vn = np.diag(deltas2_n)\n rt = np.sum(V)/np.sum(Vn)\n fac,gamman = get_fac(Vn,V,K)\n for i in range(Xn.shape[0]):\n xx = Xn[i,].argmax()\n Xn[i,] = update_xni(Qn[i,],W,rt,fac[xx],gamman[xx],K)\n return Xn\n\ndef mcr(x,y):\n cm = contingency_matrix(x,y)\n return (cm.max(axis = 0).sum())*1./cm.sum()\n\ndef get_Qn(adj,K):\n if sp.sparse.issparse(adj):\n eig_decomp = sp.sparse.linalg.eigs(adj,K)\n else:\n eig_decomp = eig(adj)\n args = np.argsort(-abs(eig_decomp[0]),)[:K]\n D = (eig_decomp[0][args])\n U = (eig_decomp[1][:,args])\n return abs(np.matmul(U,np.diag(D)))\n\ndef get_counts(X):\n delta2_n = np.array([np.diag(np.sum(X[i],axis=0)) for i in range(len(X))])\n delta2 = np.sum(delta2_n,axis=0)\n\n gamma_n = np.array([np.sum(inv(delta2)*delta2_n[i]) for i in range(len(X))])\n return delta2_n, delta2, gamma_n \n\nclass jointSBM(object):\n def __init__(self, graphs, K, \\\n edgelist = False,\n tol = 1e-5, groundTruth = None,\n init = 'kmeans++', seed = 242, **kwargs):\n graphs = graphs.copy()\n if (type(graphs)!=dict):\n self.graphNames = [\"graph\"+str(g) for g in range(1,len(graphs)+1)]\n graphs = dict(zip(self.graphNames,graphs))\n else: \n self.graphNames = [k for k in graphs.keys()]\n if (groundTruth!=None):\n if (type(groundTruth)==dict):\n self.groundTruth = [groundTruth[g] for g in self.graphNames]\n # self.groundTruth = [g for k,g in groundTruth.items()]\n\n\n if np.any([g.shape[0]!=g.shape[1] for k,g in graphs.items()]):\n print(\"Converting edgelists to sparse adjacency matrices...\")\n edgelist = True\n\n if edgelist:\n self.idx2node = {}\n for gg in self.graphNames:\n graphs[gg], self.idx2node[gg] = edgelist2sparse(graphs[gg],**kwargs)\n # print(\"Converted edgelists to sparse adjacency matrices.\")\n\n self.graphs = [graphs[g] for g in self.graphNames]\n n_graphs = len(graphs)\n\n\n self.n_graphs = n_graphs\n self.n_nodes_array = [self.graphs[i].shape[0] for i in range(n_graphs)]\n self.total_nodes = np.sum(self.n_nodes_array)\n\n self.K = K\n self.tol = tol \n self.init = init \n self.seed = seed\n self.data_prepared = False\n \n def prepare_data(self):\n Q = []\n X = []\n for i in tqdm(range(self.n_graphs)):\n Qn = get_Qn(self.graphs[i],self.K)*np.sqrt(self.total_nodes*1./self.n_nodes_array[i])\n Q.append(Qn)\n X.append(self.initX(Qn))\n\n self.Q = Q\n self.X = X\n self.deltas_ = get_counts(X)\n self.data_prepared = True\n\n def initX(self, Qn):\n K = self.K\n if self.init == 'kmeans++':\n km = KMeans(n_clusters=K,random_state=self.seed).fit(Qn).labels_\n Xn = np.vstack([onehot_vec(r,K) for r in km])\n else:\n random.seed(self.seed)\n Xn = np.random.multinomial(1,[1./K]*K,size = n_nodes)\n return Xn\n\n def fit(self, printLoss = False, maxIter = 200, parallel = False, n_cores = -1):\n self.maxIter = maxIter \n self.parallel = parallel \n self.n_cores = n_cores \n if not self.data_prepared:\n self.prepare_data()\n X = self.X\n Q = self.Q\n deltas_ = self.deltas_\n K = self.K\n n_graphs = self.n_graphs\n n_nodes_array = self.n_nodes_array \n Loss = [0]\n stopValue = 1\n iter = -1\n measures = {}\n while (stopValue > self.tol and iter < self.maxIter):\n t0 = time.time()\n iter = iter + 1\n W = update_W(X,Q,deltas_,K)\n\n V = np.diag(deltas_[1])\n memberships = []\n counts_memberships = np.zeros([1,K])\n if self.parallel:\n if n_cores == -1:\n num_cores = multiprocessing.cpu_count()\n else: \n num_cores = self.n_cores\n \n X = Parallel(n_jobs=num_cores)(delayed(processLoop)(Q[n],W,X[n],V,deltas_[0][n],K) for n in range(n_graphs))\n\n for x in X:\n # memberships.append(np.argmax(x,1))\n counts_memberships += np.sum(x,0)\n else:\n for n in range(n_graphs):\n X[n] = processLoop(Q[n],W,X[n],V,deltas_[0][n],K)\n counts_memberships += np.sum(X[n],0)\n \n if (np.sum(counts_memberships==0.)>0):\n iter = 1\n logging.warning(\"Restarting...\")\n X = [np.random.multinomial(1,[1./K]*K,size = n_nodes_array[i]) for i in range(n_graphs)]\n\n memberships = [np.argmax(X[n],1) for n in range(len(X))]\n deltas_ = get_counts(X)\n \n loss = np.ndarray([n_graphs])\n for n in range(n_graphs):\n XW = np.matmul(X[n],W)\n rt = np.sum(deltas_[1])/np.sum(deltas_[0][n])\n term = np.sqrt(np.matmul(inv(deltas_[1]),deltas_[0][n])) + np.sqrt(np.eye(K)*1./rt)\n loss[n] = deltas_[2][n]*frobenius_norm(XW-Q[n])**2 + frobenius_norm(np.matmul(Q[n],term))**2\n t1 = time.time()\n Loss.append(np.sum(loss))\n if printLoss:\n print(\"Iter: {} | Loss: {}\".format(iter, Loss[iter]))\n\n stopValue = abs(Loss[iter] - Loss[iter-1])\n\n if (self.groundTruth!=None):\n measures[iter] = self.evalutate(memberships)\n measures[iter]['Time'] = t1-t0\n else:\n measures[iter] = {'Time':t1-t0}\n \n theta = estimateTheta(X,self.graphs)\n order = np.argsort(-1*np.diag(theta),)\n theta = theta[order,][:,order]\n self.theta = theta\n\n self.W = W[order,]\n\n memberships = []\n for n in range(n_graphs):\n X[n] = X[n][:,order]\n memberships.append(dict(zip(range(1,len(X[n])+1),np.argmax(X[n],1))))\n\n memberships = dict(zip(self.graphNames,memberships))\n self.memberships = memberships\n self.X = X\n self.measures = measures\n self.iter = iter\n\n return memberships, theta, W, measures\n\n def evalutate(self, memberships):\n groundTruth = self.groundTruth\n n_graphs = self.n_graphs\n individual_nmi = np.zeros([n_graphs])\n individual_ari = np.zeros([n_graphs])\n individual_mcr = np.zeros([n_graphs])\n for n in range(n_graphs):\n # print(n)\n individual_nmi[n] = nmi(memberships[n],groundTruth[n])\n individual_ari[n] = ari(memberships[n],groundTruth[n])\n individual_mcr[n] = mcr(memberships[n],groundTruth[n])\n\n trueMemberships_stacked = np.reshape(np.hstack(groundTruth),[-1])\n memberships_stacked = np.hstack(memberships)\n overall_nmi = nmi(memberships_stacked,trueMemberships_stacked)\n overall_ari = ari(memberships_stacked,trueMemberships_stacked)\n overall_mcr = mcr(memberships_stacked,trueMemberships_stacked)\n \n return {\"NMI\" : {'nmi' : np.mean(individual_nmi),'overall_nmi' : overall_nmi},\"ARI\" : {'ari' : np.mean(individual_ari),'overall_ari' : overall_ari},\"MCR\" : {'mcr' : np.mean(individual_mcr),'overall_mcr' : overall_mcr}}\n\n"
] | [
[
"numpy.sum",
"numpy.diag",
"sklearn.cluster.KMeans",
"sklearn.metrics.cluster.contingency_matrix",
"sklearn.metrics.cluster.normalized_mutual_info_score",
"numpy.argmin",
"scipy.sparse.linalg.eigs",
"sklearn.metrics.cluster.adjusted_rand_score",
"numpy.ndarray",
"numpy.random.multinomial",
"numpy.mean",
"numpy.eye",
"numpy.zeros",
"numpy.argmax",
"numpy.hstack",
"numpy.matmul",
"scipy.sparse.issparse",
"numpy.linalg.inv",
"numpy.sqrt",
"scipy.linalg.eig"
]
] |
DeepPSP/cpsc2021 | [
"165790be750421eb0e0f0fe3129d03dddc250ada"
] | [
"score_2021.py"
] | [
"#!/usr/bin/env python3\n\nimport numpy as np\nimport json\nimport os\nimport sys\n\nimport scipy.io as sio\nimport wfdb\n\n\"\"\"\nWritten by: Xingyao Wang, Chengyu Liu\n School of Instrument Science and Engineering\n Southeast University, China\n [email protected]\n\"\"\"\n\nR = np.array([[1, -1, -0.5], [-2, 1, 0], [-1, 0, 1]])\n\n\nclass RefInfo:\n def __init__(self, sample_path):\n self.sample_path = sample_path\n (\n self.fs,\n self.len_sig,\n self.beat_loc,\n self.af_starts,\n self.af_ends,\n self.class_true,\n ) = self._load_ref()\n self.endpoints_true = np.dstack((self.af_starts, self.af_ends))[0, :, :]\n # self.endpoints_true = np.concatenate((self.af_starts, self.af_ends), axis=-1)\n\n if self.class_true == 1 or self.class_true == 2:\n (\n self.onset_score_range,\n self.offset_score_range,\n ) = self._gen_endpoint_score_range()\n else:\n self.onset_score_range, self.offset_score_range = None, None\n\n def _load_ref(self):\n sig, fields = wfdb.rdsamp(self.sample_path)\n ann_ref = wfdb.rdann(self.sample_path, \"atr\")\n\n fs = fields[\"fs\"]\n length = len(sig)\n sample_descrip = fields[\"comments\"]\n\n beat_loc = np.array(ann_ref.sample) # r-peak locations\n ann_note = np.array(ann_ref.aux_note) # rhythm change flag\n\n af_start_scripts = np.where((ann_note == \"(AFIB\") | (ann_note == \"(AFL\"))[0]\n af_end_scripts = np.where(ann_note == \"(N\")[0]\n\n if \"non atrial fibrillation\" in sample_descrip:\n class_true = 0\n elif \"persistent atrial fibrillation\" in sample_descrip:\n class_true = 1\n elif \"paroxysmal atrial fibrillation\" in sample_descrip:\n class_true = 2\n else:\n print(\"Error: the recording is out of range!\")\n\n return -1\n\n return fs, length, beat_loc, af_start_scripts, af_end_scripts, class_true\n\n def _gen_endpoint_score_range(self):\n \"\"\" \"\"\"\n onset_range = np.zeros((self.len_sig,), dtype=np.float)\n offset_range = np.zeros((self.len_sig,), dtype=np.float)\n for i, af_start in enumerate(self.af_starts):\n if self.class_true == 2:\n if max(af_start - 1, 0) == 0:\n onset_range[: self.beat_loc[af_start + 2]] += 1\n elif max(af_start - 2, 0) == 0:\n onset_range[\n self.beat_loc[af_start - 1] : self.beat_loc[af_start + 2]\n ] += 1\n onset_range[: self.beat_loc[af_start - 1]] += 0.5\n else:\n onset_range[\n self.beat_loc[af_start - 1] : self.beat_loc[af_start + 2]\n ] += 1\n onset_range[\n self.beat_loc[af_start - 2] : self.beat_loc[af_start - 1]\n ] += 0.5\n onset_range[\n self.beat_loc[af_start + 2] : self.beat_loc[af_start + 3]\n ] += 0.5\n elif self.class_true == 1:\n onset_range[: self.beat_loc[af_start + 2]] += 1\n onset_range[\n self.beat_loc[af_start + 2] : self.beat_loc[af_start + 3]\n ] += 0.5\n for i, af_end in enumerate(self.af_ends):\n if self.class_true == 2:\n if min(af_end + 1, len(self.beat_loc) - 1) == len(self.beat_loc) - 1:\n offset_range[self.beat_loc[af_end - 2] :] += 1\n elif min(af_end + 2, len(self.beat_loc) - 1) == len(self.beat_loc) - 1:\n offset_range[\n self.beat_loc[af_end - 2] : self.beat_loc[af_end + 1]\n ] += 1\n offset_range[self.beat_loc[af_end + 1] :] += 0.5\n else:\n offset_range[\n self.beat_loc[af_end - 2] : self.beat_loc[af_end + 1]\n ] += 1\n offset_range[\n self.beat_loc[af_end + 1] : min(\n self.beat_loc[af_end + 2], self.len_sig - 1\n )\n ] += 0.5\n offset_range[\n self.beat_loc[af_end - 3] : self.beat_loc[af_end - 2]\n ] += 0.5\n elif self.class_true == 1:\n offset_range[self.beat_loc[af_end - 2] :] += 1\n offset_range[\n self.beat_loc[af_end - 3] : self.beat_loc[af_end - 2]\n ] += 0.5\n\n return onset_range, offset_range\n\n\ndef load_ans(ans_file):\n endpoints_pred = []\n if ans_file.endswith(\".json\"):\n json_file = open(ans_file, \"r\")\n ans_dic = json.load(json_file)\n endpoints_pred = np.array(ans_dic[\"predict_endpoints\"])\n\n elif ans_file.endswith(\".mat\"):\n ans_struct = sio.loadmat(ans_file)\n endpoints_pred = ans_struct[\"predict_endpoints\"] - 1\n\n return endpoints_pred\n\n\ndef ue_calculate(endpoints_pred, endpoints_true, onset_score_range, offset_score_range):\n score = 0\n ma = len(endpoints_true)\n mr = len(endpoints_pred)\n\n if mr == 0:\n score = 0\n\n else:\n for [start, end] in endpoints_pred:\n score += onset_score_range[int(start)]\n score += offset_score_range[int(end)]\n\n score *= ma / max(ma, mr)\n\n return score\n\n\ndef ur_calculate(class_true, class_pred):\n score = R[int(class_true), int(class_pred)]\n\n return score\n\n\ndef score(data_path, ans_path):\n # AF burden estimation\n SCORE = []\n\n def is_mat_or_json(file):\n return (file.endswith(\".json\")) + (file.endswith(\".mat\"))\n\n ans_set = filter(is_mat_or_json, os.listdir(ans_path))\n # test_set = open(os.path.join(data_path, 'RECORDS'), 'r').read().splitlines()\n for i, ans_sample in enumerate(ans_set):\n sample_nam = ans_sample.split(\".\")[0]\n sample_path = os.path.join(data_path, sample_nam)\n\n endpoints_pred = load_ans(os.path.join(ans_path, ans_sample))\n TrueRef = RefInfo(sample_path)\n\n if len(endpoints_pred) == 0:\n class_pred = 0\n elif (\n len(endpoints_pred) == 1\n and np.diff(endpoints_pred)[-1] == TrueRef.len_sig - 1\n ):\n class_pred = 1\n else:\n class_pred = 2\n\n ur_score = ur_calculate(TrueRef.class_true, class_pred)\n\n if TrueRef.class_true == 1 or TrueRef.class_true == 2:\n ue_score = ue_calculate(\n endpoints_pred,\n TrueRef.endpoints_true,\n TrueRef.onset_score_range,\n TrueRef.offset_score_range,\n )\n else:\n ue_score = 0\n\n u = ur_score + ue_score\n SCORE.append(u)\n\n score_avg = np.mean(SCORE)\n\n return score_avg\n\n\nif __name__ == \"__main__\":\n TESTSET_PATH = sys.argv[1]\n RESULT_PATH = sys.argv[2]\n score_avg = score(TESTSET_PATH, RESULT_PATH)\n print(\"AF Endpoints Detection Performance: %0.4f\" % score_avg)\n\n with open(os.path.join(RESULT_PATH, \"score.txt\"), \"w\") as score_file:\n print(\"AF Endpoints Detection Performance: %0.4f\" % score_avg, file=score_file)\n\n score_file.close()\n"
] | [
[
"scipy.io.loadmat",
"numpy.zeros",
"numpy.diff",
"numpy.dstack",
"numpy.array",
"numpy.where",
"numpy.mean"
]
] |
kamal-rahimi/SentenceCorrection | [
"19138ebbdf1073f070a1982d3991de063c0d27d7"
] | [
"process_sentence.py"
] | [
"\"\"\"\nEstimates the likihood of an input senetnce and finds an order of words\nthat is most likely in the longuage model\n\"\"\"\n\nimport os\nimport argparse\nimport pickle\n\nfrom keras.models import load_model\nfrom keras.preprocessing.sequence import pad_sequences\nfrom keras import backend as k\n\nimport numpy as np\n\nfrom itertools import permutations\n\nfrom nlp_tools import strip_punctuations\n\ndef analyze_sequence(model, words_id_order, max_sentence_words):\n \"\"\" Computes the liklihood of the input sequnce of words using the longuage model\n Args:\n model: trained longuage model object\n words_ids: inout sequnce of word ids\n max_sentence_words: maximum number of words in a senetnce\n Returns:\n p_sentence: the liklihood of inout sequnce in the longuage model\n p_words: a python array of the liklihood of each word given its predecessor words\n \"\"\"\n p_words = [1]\n p_sentence = 1\n for word_index in range(1, len(words_id_order)-1):\n seq = words_id_order[:word_index]\n x = pad_sequences([seq], maxlen=max_sentence_words-1, truncating='pre')\n y = words_id_order[word_index]\n predict_prob = model.predict(x, verbose=0)\n\n predict_prob = np.array(predict_prob).reshape(-1,)\n prob = predict_prob[y]\n p_words.append(prob)\n p_sentence = p_sentence*prob\n\n return p_sentence, p_words\n\ndef process_sentence(model_name, input_sentence, window_size, max_sentence_words = 12):\n \"\"\" analyzes the inout sentnces and reorders the word to form a senetnces which\n has the highest liklihood in the longuage model.\n\n Args:\n model: trained longuage model object\n word2id: dictionary to convert from word to id\n id2word: dictionary to convert from id to word\n window_size: word reordering search window size\n input_sentnce (text): input sentnce\n max_sentence_words: maximum number of words in a senetnce\n Returns:\n most_likely_sentence: the word reordred senetnce that has highes liklihood in the longuage model\n most_likely_word_order_prob: liklihood of the reordred sentence\n \"\"\"\n model_path = './models/' + model_name + '_model.h5'\n meta_data_path = './models/' + model_name + '_metadata.pickle'\n if (os.path.isfile(model_path) == True) and (os.path.isfile(model_path) == True):\n model = load_model(model_path)\n with open(meta_data_path,'rb') as f:\n word2id, id2word = pickle.load(f)\n else:\n print('No model with name \\\"%s\\\" is trained yet' % model_name)\n return\n\n\n input_sentence = strip_punctuations(input_sentence)\n input_sentence = input_sentence.lower()\n sentence_words = input_sentence.split()\n sentence_words_id = [word2id[word] if word in word2id else word2id['<UNK>'] for word in sentence_words]\n\n full_sentence_words_id = [word2id['<BGN>']] + sentence_words_id + [word2id['<EOS>']]\n inout_word_order_prob, _ = analyze_sequence(model, full_sentence_words_id, max_sentence_words)\n\n sentence_words_id_permutations = []\n num_iterations = max(1, len(sentence_words_id) - window_size + 1)\n for i in range(0, num_iterations):\n words_id_permutations = [ sentence_words_id[0 : i] + list(l) for l in permutations(sentence_words_id[i : window_size + i]) ]\n num_permutations = len(words_id_permutations)\n sentence_size = len(words_id_permutations[0])\n\n words_id_permutations_prob = []\n for words_id_order_index in range(0, num_permutations):\n words_id_order = list(words_id_permutations[words_id_order_index])\n words_id_order = [word2id['<BGN>']] + words_id_order\n if i == num_iterations-1:\n words_id_order = words_id_order + [word2id['<EOS>']]\n\n p_sentence, p_words = analyze_sequence(model, words_id_order, max_sentence_words)\n\n words_id_permutations_prob.append(p_sentence)\n\n most_likely_word_order_index = np.argmax(words_id_permutations_prob)\n most_likely_word_order_prob = words_id_permutations_prob[most_likely_word_order_index]\n most_likely_words_id_order = words_id_permutations[most_likely_word_order_index]\n\n sentence_words_id = most_likely_words_id_order + sentence_words_id[window_size + i : ]\n\n k.clear_session()\n\n most_likely_words_order = [id2word[id] for id in sentence_words_id]\n most_likely_sentence = ' '.join(most_likely_words_order)\n return inout_word_order_prob, most_likely_sentence, most_likely_word_order_prob\n\n\ndef main():\n\n # construct the argument parser and parse the arguments\n ap = argparse.ArgumentParser()\n ap.add_argument(\"-n\", \"--name\", type=str, default=\"English\", help=\"specify the longuage model name\")\n ap.add_argument(\"-s\", \"--sentence\", type=str, default=\"This is\", help=\"specify the longuage model name\")\n ap.add_argument(\"-w\", \"--window\", type=int, default=5, help=\"specify the window size to reorder words\")\n ap.add_argument(\"-g\", \"--gpu\", help=\"Specify to use GPU for training the model\", action='store_true')\n\n args = vars(ap.parse_args())\n model_name = args[\"name\"]\n input_sentence = args['sentence']\n window_size = args['window']\n use_gpu = args[\"gpu\"]\n\n if use_gpu:\n config_gpu()\n\n input_sentences_liklihood, corrected_sentence, corrected_sentence_liklihood = process_sentence(model_name, input_sentence, window_size)\n print('\\nInput: ')\n print(input_sentence)\n print('Liklihood:')\n print(input_sentences_liklihood)\n print('\\nCorrected: ')\n print(corrected_sentence)\n print('Liklihood:')\n print(corrected_sentence_liklihood)\n print('\\n')\n\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"numpy.array",
"numpy.argmax"
]
] |
wjwyyjr/Gem5_task_graph | [
"0e233b5053d6dcd518a2ad6fddd23eaeb9c3a8ee"
] | [
"my_scripts/10_03/different_memory_access/plot.py"
] | [
"from io import SEEK_CUR\nfrom os import name\nfrom types import FunctionType\nimport matplotlib.pyplot as plt\nfrom matplotlib.pyplot import legend, plot, xticks\n\n## class for plot function\nclass PlotFunction():\n \"\"\"Make Data visualization Easier !\"\"\"\n def __init__(self, y_data, x_label, y_label, x_ticklabels=[], x_ticks=[], title=''):\n self.y_data=y_data\n self.x_label=x_label\n self.y_label=y_label\n self.x_ticklabels=x_ticklabels\n self.x_ticks=x_ticks\n if title == '':\n self.title=self.y_label+\" vs. \"+self.x_label\n else:\n self.title=self.y_label+\" vs. \"+self.x_label+title\n\n def plot_figs(self):\n plt.clf()\n legend_list = []\n line_type=['-x', '-*', '-^', '-o', '-s', '-<', '-v', '-D']\n plt_ptrs = []\n i = 0\n default_xticks_len = 0\n for key, value in self.y_data.items():\n legend_list.append(key)\n assert(i < len(line_type)) # aviod over the range of line_type\n plt_ptr, = plt.plot([int(x) for x in value], line_type[i])\n plt_ptrs.append(plt_ptr)\n i += 1\n\n if default_xticks_len == 0:\n default_xticks_len = len(value)\n\n plt.title(self.title)\n plt.xlabel(self.x_label)\n plt.ylabel(self.y_label)\n plt.legend(plt_ptrs, legend_list)\n ax = plt.gca()\n\n if self.x_ticklabels != []:\n ax.set_xticklabels(self.x_ticklabels)\n else:\n ax.set_xticklabels([str(x) for x in range(default_xticks_len)])\n\n if self.x_ticks != []:\n ax.set_xticks(self.x_ticks)\n else:\n ax.set_xticks([x for x in range(default_xticks_len)])\n\n plt.tight_layout()\n\n def save_figs(self, dir, filename=''):\n self.plot_figs()\n name=''\n if filename != '':\n name = filename + '.jpg'\n else:\n name = self.title + '.jpg'\n\n plt.savefig(dir + name)\n\n def plot_pie(self, dir='./', title='', legend_list=[], if_save=True):\n plt.clf()\n\n if legend_list == []:\n legend_list = ['HQM', 'Core-0', 'PE-1 PE-2', 'DDR-0', 'PE-3 PE-4 PE-5', 'PE-13', 'Core-1', \\\n 'Core-2', 'PE-6 PE-7 PE-8', 'DDR-1', 'PE-9 PE-10 PE-11 PE-12', 'Core-3']\n\n explode = [0.01] * len(self.y_data)\n plt.pie(self.y_data, explode=explode, labels=legend_list)\n plt.title(title)\n plt.tight_layout()\n if if_save:\n plt.savefig(dir+title+'.jpg')\n\n\n## System Path\ndir_path = \"/home/wj/test/Gem5_task_graph/my_STATS/10_03/different_memory_access/\"\nresult_path = dir_path+\"results.txt\"\nfig_path = dir_path+\"FIGS/\"\nlink_result_path = dir_path+\"LINK_RESULT/\"\nlog_path = dir_path + \"log\"\n\n## Parameter Setting\napp=[1, 2, 3, 4, 5]\niters=[100]\nmem_access=['10', '20', '30', '40', '50']\nmem_type = ['DDR3']\n\n## Read File -> result.txt\nwith open(result_path) as input_file:\n input_data = input_file.readlines()\n\n# use dict to store info {name: [...]}\ninput_data_dict = {}\n\nfor i in range(1, len(input_data)):\n input_data_dict[input_data[i].split()[0]] = input_data[i].strip().split()[1:]\n\nete_delay = {}\nflits = {}\nhops = {}\nlatency = {}\nnetwork_latency = {}\nqueueing_latency = {}\nfor app_num in range(1,6):\n app_name = \"App_0\" + str(app_num)\n ete_delay[app_name] = []\n flits[app_name] = []\n hops[app_name] = []\n latency[app_name] = []\n network_latency[app_name] = []\n queueing_latency[app_name] = []\n for iter in iters:\n for mc in mem_access:\n for mt in mem_type:\n filename = \"Application_0\" + str(app_num) + '_Iters_' + str(iter) + '_Memory_Access_' +\\\n str(mc) + '_Memory_Type_' + str(mt)\n ete_delay[app_name].append(input_data_dict[filename][5])\n flits[app_name].append(input_data_dict[filename][0])\n hops[app_name].append(input_data_dict[filename][1])\n latency[app_name].append(input_data_dict[filename][2])\n network_latency[app_name].append(input_data_dict[filename][3])\n queueing_latency[app_name].append(input_data_dict[filename][4])\n\np = PlotFunction(ete_delay, 'Memory Access', 'Average ETE Delay', mem_access)\np.save_figs(fig_path)\n\n\n## Read File -> log\nif 0:\n with open(log_path) as log_file:\n log_data = log_file.readlines()\n\n for app in app:\n\n ete_delay = {}\n average_ete_delay = {}\n\n for iter in iters:\n for mc in mem_access:\n for mt in mem_type:\n key_word = 'Application_0' + str(app) + '_Iters_' + str(iter) + '_Memory_Access_' +\\\n str(mc) + '_Memory_Type_' + str(mt)\n start_idx = -1\n for i in range(len(log_data)):\n if key_word in log_data[i]:\n start_idx = i + 3\n break\n assert(start_idx != -1)\n\n each_iter_data = []\n aver_data = []\n total_delay = 0\n assert(log_data[start_idx+iter-1].strip().split()[1] == str(iter-1))\n for i in range(start_idx, start_idx+iter):\n delay = log_data[i].strip().split()[-1]\n total_delay += int(delay)\n each_iter_data.append(delay)\n aver_data.append(total_delay/(i-start_idx+1))\n\n x_index = 'Memory_Access_' + mc # for legend\n ete_delay[x_index] = each_iter_data\n average_ete_delay[x_index] = aver_data\n\n x_ticklabels=['10', '20', '30', '40', '50', '60', '70', '80', '90', '100']\n x_ticks=[i*10 for i in range(1,11)]\n p = PlotFunction(ete_delay, \"Execution Iterations\", \"ETE Delay\", x_ticklabels, x_ticks, ' for_App_0'+str(app))\n p.save_figs(fig_path)\n\n p1 = PlotFunction(average_ete_delay, \"Execution Iterations\", \"Average ETE Delay\", x_ticklabels, x_ticks, ' for_App_0'+str(app))\n p1.save_figs(fig_path)\n"
] | [
[
"matplotlib.pyplot.legend",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.pie",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.title",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel"
]
] |
ruihan0495/EfficientDet | [
"f61b77343a9782d85747ced6704c35a49528934a"
] | [
"utils/graph_funcs.py"
] | [
"import tensorflow as tf\n############################################################\n# Miscellenous Graph Functions\n############################################################\n\ndef trim_zeros_graph(boxes, name='trim_zeros'):\n \"\"\"Often boxes are represented with matrices of shape [N, 4] and\n are padded with zeros. This removes zero boxes.\n boxes: [N, 4] matrix of boxes.\n non_zeros: [N] a 1D boolean mask identifying the rows to keep\n \"\"\"\n non_zeros = tf.cast(tf.reduce_sum(tf.abs(boxes), axis=1), tf.bool)\n boxes = tf.boolean_mask(boxes, non_zeros, name=name)\n return boxes, non_zeros\n\n\ndef batch_pack_graph(x, counts, num_rows):\n \"\"\"Picks different number of values from each row\n in x depending on the values in counts.\n \"\"\"\n outputs = []\n for i in range(num_rows):\n outputs.append(x[i, :counts[i]])\n return tf.concat(outputs, axis=0)\n\n\ndef norm_boxes_graph(boxes, shape):\n \"\"\"Converts boxes from pixel coordinates to normalized coordinates.\n boxes: [..., (y1, x1, y2, x2)] in pixel coordinates\n shape: [..., (height, width)] in pixels\n Note: In pixel coordinates (y2, x2) is outside the box. But in normalized\n coordinates it's inside the box.\n Returns:\n [..., (y1, x1, y2, x2)] in normalized coordinates\n \"\"\"\n h, w = tf.split(tf.cast(shape, tf.float32), 2)\n scale = tf.concat([h, w, h, w], axis=-1) - tf.constant(1.0)\n shift = tf.constant([0., 0., 1., 1.])\n return tf.divide(boxes - shift, scale)\n\n\ndef denorm_boxes_graph(boxes, shape):\n \"\"\"Converts boxes from normalized coordinates to pixel coordinates.\n boxes: [..., (y1, x1, y2, x2)] in normalized coordinates\n shape: [..., (height, width)] in pixels\n Note: In pixel coordinates (y2, x2) is outside the box. But in normalized\n coordinates it's inside the box.\n Returns:\n [..., (y1, x1, y2, x2)] in pixel coordinates\n \"\"\"\n h, w = tf.split(tf.cast(shape, tf.float32), 2)\n scale = tf.concat([h, w, h, w], axis=-1) - tf.constant(1.0)\n shift = tf.constant([0., 0., 1., 1.])\n return tf.cast(tf.round(tf.multiply(boxes, scale) + shift), tf.int32)\n\ndef overlaps_graph(boxes1, boxes2):\n \"\"\"Computes IoU overlaps between two sets of boxes.\n boxes1, boxes2: [N, (y1, x1, y2, x2)].\n \"\"\"\n # 1. Tile boxes2 and repeat boxes1. This allows us to compare\n # every boxes1 against every boxes2 without loops.\n # TF doesn't have an equivalent to np.repeat() so simulate it\n # using tf.tile() and tf.reshape.\n b1 = tf.reshape(tf.tile(tf.expand_dims(boxes1, 1),\n [1, 1, tf.shape(boxes2)[0]]), [-1, 4])\n b2 = tf.tile(boxes2, [tf.shape(boxes1)[0], 1])\n # 2. Compute intersections\n b1_y1, b1_x1, b1_y2, b1_x2 = tf.split(b1, 4, axis=1)\n b2_y1, b2_x1, b2_y2, b2_x2 = tf.split(b2, 4, axis=1)\n y1 = tf.maximum(b1_y1, b2_y1)\n x1 = tf.maximum(b1_x1, b2_x1)\n y2 = tf.minimum(b1_y2, b2_y2)\n x2 = tf.minimum(b1_x2, b2_x2)\n intersection = tf.maximum(x2 - x1, 0) * tf.maximum(y2 - y1, 0)\n # 3. Compute unions\n b1_area = (b1_y2 - b1_y1) * (b1_x2 - b1_x1)\n b2_area = (b2_y2 - b2_y1) * (b2_x2 - b2_x1)\n union = b1_area + b2_area - intersection\n # 4. Compute IoU and reshape to [boxes1, boxes2]\n iou = intersection / union\n overlaps = tf.reshape(iou, [tf.shape(boxes1)[0], tf.shape(boxes2)[0]])\n return overlaps\n\ndef batch_slice(inputs, graph_fn, batch_size, names=None):\n \"\"\"Splits inputs into slices and feeds each slice to a copy of the given\n computation graph and then combines the results. It allows you to run a\n graph on a batch of inputs even if the graph is written to support one\n instance only.\n inputs: list of tensors. All must have the same first dimension length\n graph_fn: A function that returns a TF tensor that's part of a graph.\n batch_size: number of slices to divide the data into.\n names: If provided, assigns names to the resulting tensors.\n \"\"\"\n if not isinstance(inputs, list):\n inputs = [inputs]\n\n outputs = []\n for i in range(batch_size):\n inputs_slice = [x[i] for x in inputs]\n output_slice = graph_fn(*inputs_slice)\n if not isinstance(output_slice, (tuple, list)):\n output_slice = [output_slice]\n outputs.append(output_slice)\n # Change outputs from a list of slices where each is\n # a list of outputs to a list of outputs and each has\n # a list of slices\n outputs = list(zip(*outputs))\n\n if names is None:\n names = [None] * len(outputs)\n\n result = [tf.stack(o, axis=0, name=n)\n for o, n in zip(outputs, names)]\n if len(result) == 1:\n result = result[0]\n\n return result\n\ndef norm_boxes_graph(boxes, shape):\n \"\"\"Converts boxes from pixel coordinates to normalized coordinates.\n boxes: [..., (y1, x1, y2, x2)] in pixel coordinates\n shape: [..., (height, width)] in pixels\n Note: In pixel coordinates (y2, x2) is outside the box. But in normalized\n coordinates it's inside the box.\n Returns:\n [..., (y1, x1, y2, x2)] in normalized coordinates\n \"\"\"\n h, w = tf.split(tf.cast(shape, tf.float32), 2)\n scale = tf.concat([h, w, h, w], axis=-1) - tf.constant(1.0)\n shift = tf.constant([0., 0., 1., 1.])\n return tf.divide(boxes - shift, scale)\n\n\ndef denorm_boxes_graph(boxes, shape):\n \"\"\"Converts boxes from normalized coordinates to pixel coordinates.\n boxes: [..., (y1, x1, y2, x2)] in normalized coordinates\n shape: [..., (height, width)] in pixels\n Note: In pixel coordinates (y2, x2) is outside the box. But in normalized\n coordinates it's inside the box.\n Returns:\n [..., (y1, x1, y2, x2)] in pixel coordinates\n \"\"\"\n h, w = tf.split(tf.cast(shape, tf.float32), 2)\n scale = tf.concat([h, w, h, w], axis=-1) - tf.constant(1.0)\n shift = tf.constant([0., 0., 1., 1.])\n return tf.cast(tf.round(tf.multiply(boxes, scale) + shift), tf.int32)"
] | [
[
"tensorflow.divide",
"tensorflow.minimum",
"tensorflow.stack",
"tensorflow.shape",
"tensorflow.multiply",
"tensorflow.expand_dims",
"tensorflow.cast",
"tensorflow.abs",
"tensorflow.concat",
"tensorflow.boolean_mask",
"tensorflow.constant",
"tensorflow.split",
"tensorflow.maximum"
]
] |
lp2333/PARL | [
"f508bc6085420431b504441c7ff129e64826603e"
] | [
"parl/env/tests/continuous_wrappers_test.py"
] | [
"# Copyright (c) 2018 PaddlePaddle 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\nimport gym\nimport numpy as np\nimport unittest\nfrom parl.env.continuous_wrappers import ActionMappingWrapper\n\n\nclass MockEnv(gym.Env):\n def __init__(self, low, high):\n self.action_space = gym.spaces.Box(low=low, high=high, shape=(3, ))\n self._max_episode_steps = 1000\n\n def step(self, action):\n self.action = action\n\n def reset(self):\n return None\n\n\nclass TestActionMappingWrapper(unittest.TestCase):\n def test_action_mapping(self):\n origin_act = np.array([-1.0, 0.0, 1.0])\n\n env = MockEnv(0.0, 1.0)\n wrapper_env = ActionMappingWrapper(env)\n wrapper_env.step(origin_act)\n self.assertListEqual(list(env.action), [0.0, 0.5, 1.0])\n\n env = MockEnv(-2.0, 2.0)\n wrapper_env = ActionMappingWrapper(env)\n wrapper_env.step(origin_act)\n self.assertListEqual(list(env.action), [-2.0, 0.0, 2.0])\n\n env = MockEnv(-5.0, 10.0)\n wrapper_env = ActionMappingWrapper(env)\n wrapper_env.step(origin_act)\n self.assertListEqual(list(env.action), [-5.0, 2.5, 10.0])\n\n\nif __name__ == '__main__':\n unittest.main()\n"
] | [
[
"numpy.array"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.