repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list |
|---|---|---|---|---|
THUMNLab/AutoGL | [
"7b551961e90f5042d9b91d92c083f3f09dd9dbdd",
"7b551961e90f5042d9b91d92c083f3f09dd9dbdd"
] | [
"autogl/module/nas/estimator/one_shot.py",
"autogl/solver/classifier/graph_classifier.py"
] | [
"import torch.nn as nn\nimport torch.nn.functional as F\n\nfrom . import register_nas_estimator\nfrom ..space import BaseSpace\nfrom .base import BaseEstimator\n\n\n@register_nas_estimator(\"oneshot\")\nclass OneShotEstimator(BaseEstimator):\n \"\"\"\n One shot estimator.\n\n Use model directly to get estimations.\n \"\"\"\n\n def infer(self, model: BaseSpace, dataset, mask=\"train\"):\n device = next(model.parameters()).device\n dset = dataset[0].to(device)\n pred = model(dset)[getattr(dset, f\"{mask}_mask\")]\n y = dset.y[getattr(dset, f\"{mask}_mask\")]\n loss = getattr(F, self.loss_f)(pred, y)\n # acc=sum(pred.max(1)[1]==y).item()/y.size(0)\n probs = F.softmax(pred, dim=1).detach().cpu().numpy()\n y = y.cpu()\n metrics = [eva.evaluate(probs, y) for eva in self.evaluation]\n return metrics, loss\n",
"\"\"\"\nAuto Classfier for Graph Node Classification\n\"\"\"\nimport time\nimport json\n\nfrom copy import deepcopy\n\nimport torch\nimport numpy as np\nimport yaml\n\nfrom .base import BaseClassifier\nfrom ...module.feature import FEATURE_DICT\nfrom ...module.model import BaseModel, MODEL_DICT\nfrom ...module.train import TRAINER_DICT, get_feval, BaseGraphClassificationTrainer\nfrom ..base import _initialize_single_model, _parse_hp_space\nfrom ..utils import LeaderBoard, set_seed\nfrom ...datasets import utils\nfrom ...utils import get_logger\n\nLOGGER = get_logger(\"GraphClassifier\")\n\n\nclass AutoGraphClassifier(BaseClassifier):\n \"\"\"\n Auto Multi-class Graph Classifier.\n\n Used to automatically solve the graph classification problems.\n\n Parameters\n ----------\n feature_module: autogl.module.feature.BaseFeatureEngineer or str or None\n The (name of) auto feature engineer used to process the given dataset.\n Disable feature engineer by setting it to ``None``. Default ``deepgl``.\n\n graph_models: list of autogl.module.model.BaseModel or list of str\n The (name of) models to be optimized as backbone. Default ``['gat', 'gcn']``.\n\n hpo_module: autogl.module.hpo.BaseHPOptimizer or str or None\n The (name of) hpo module used to search for best hyper parameters.\n Disable hpo by setting it to ``None``. Default ``anneal``.\n\n ensemble_module: autogl.module.ensemble.BaseEnsembler or str or None\n The (name of) ensemble module used to ensemble the multi-models found.\n Disable ensemble by setting it to ``None``. Default ``voting``.\n\n max_evals: int (Optional)\n If given, will set the number eval times the hpo module will use.\n Only be effective when hpo_module is ``str``. Default ``None``.\n\n trainer_hp_space: Iterable[dict] (Optional)\n trainer hp space or list of trainer hp spaces configuration.\n If a single trainer hp is given, will specify the hp space of trainer for\n every model. If a list of trainer hp is given, will specify every model\n with corrsponding trainer hp space. Default ``None``.\n\n model_hp_spaces: Iterable[Iterable[dict]] (Optional)\n model hp space configuration.\n If given, will specify every hp space of every passed model. Default ``None``.\n\n size: int (Optional)\n The max models ensemble module will use. Default ``None``.\n\n device: torch.device or str\n The device where model will be running on. If set to ``auto``, will use gpu\n when available. You can also specify the device by directly giving ``gpu`` or\n ``cuda:0``, etc. Default ``auto``.\n \"\"\"\n\n # pylint: disable=W0102\n\n def __init__(\n self,\n feature_module=None,\n graph_models=[\"gin\", \"topkpool\"],\n # nas_algorithms=None,\n # nas_spaces=None,\n # nas_estimators=None,\n hpo_module=\"anneal\",\n ensemble_module=\"voting\",\n max_evals=50,\n default_trainer=None,\n trainer_hp_space=None,\n model_hp_spaces=None,\n size=4,\n device=\"auto\",\n ):\n\n super().__init__(\n feature_module=feature_module,\n graph_models=graph_models,\n nas_algorithms=None, # nas_algorithms,\n nas_spaces=None, # nas_spaces,\n nas_estimators=None, # nas_estimators,\n hpo_module=hpo_module,\n ensemble_module=ensemble_module,\n max_evals=max_evals,\n default_trainer=default_trainer or \"GraphClassificationFull\",\n trainer_hp_space=trainer_hp_space,\n model_hp_spaces=model_hp_spaces,\n size=size,\n device=device,\n )\n\n self.dataset = None\n\n def _init_graph_module(\n self,\n graph_models,\n num_classes,\n num_features,\n feval,\n device,\n loss,\n num_graph_features,\n ) -> \"AutoGraphClassifier\":\n # load graph network module\n self.graph_model_list = []\n if isinstance(graph_models, (list, tuple)):\n for model in graph_models:\n if isinstance(model, str):\n if model in MODEL_DICT:\n self.graph_model_list.append(\n MODEL_DICT[model](\n num_classes=num_classes,\n num_features=num_features,\n num_graph_features=num_graph_features,\n device=device,\n init=False,\n )\n )\n else:\n raise KeyError(\"cannot find model %s\" % (model))\n elif isinstance(model, type) and issubclass(model, BaseModel):\n self.graph_model_list.append(\n model(\n num_classes=num_classes,\n num_features=num_features,\n num_graph_features=num_graph_features,\n device=device,\n init=False,\n )\n )\n elif isinstance(model, BaseModel):\n # setup the hp of num_classes and num_features\n model.set_num_classes(num_classes)\n model.set_num_features(num_features)\n model.set_num_graph_features(num_graph_features)\n self.graph_model_list.append(model.to(device))\n elif isinstance(model, BaseGraphClassificationTrainer):\n # receive a trainer list, put trainer to list\n assert (\n model.get_model() is not None\n ), \"Passed trainer should contain a model\"\n model.model.set_num_classes(num_classes)\n model.model.set_num_features(num_features)\n model.model.set_num_graph_features(num_graph_features)\n model.update_parameters(\n num_classes=num_classes,\n num_features=num_features,\n num_graph_features=num_graph_features,\n loss=loss,\n feval=feval,\n device=device,\n )\n self.graph_model_list.append(model)\n else:\n raise KeyError(\"cannot find graph network %s.\" % (model))\n else:\n raise ValueError(\n \"need graph network to be (list of) str or a BaseModel class/instance, get\",\n graph_models,\n \"instead.\",\n )\n\n # wrap all model_cls with specified trainer\n for i, model in enumerate(self.graph_model_list):\n # set model hp space\n if self._model_hp_spaces is not None:\n if self._model_hp_spaces[i] is not None:\n if isinstance(model, BaseGraphClassificationTrainer):\n model.model.hyper_parameter_space = self._model_hp_spaces[i]\n else:\n model.hyper_parameter_space = self._model_hp_spaces[i]\n # initialize trainer if needed\n if isinstance(model, BaseModel):\n name = (\n self._default_trainer\n if isinstance(self._default_trainer, str)\n else self._default_trainer[i]\n )\n model = TRAINER_DICT[name](\n model=model,\n num_features=num_features,\n num_classes=num_classes,\n loss=loss,\n feval=feval,\n device=device,\n num_graph_features=num_graph_features,\n init=False,\n )\n # set trainer hp space\n if self._trainer_hp_space is not None:\n if isinstance(self._trainer_hp_space[0], list):\n current_hp_for_trainer = self._trainer_hp_space[i]\n else:\n current_hp_for_trainer = self._trainer_hp_space\n model.hyper_parameter_space = current_hp_for_trainer\n self.graph_model_list[i] = model\n\n return self\n\n \"\"\"\n # currently disabled\n def _init_nas_module(\n self, num_features, num_classes, num_graph_features, feval, device, loss\n ):\n for algo, space, estimator in zip(\n self.nas_algorithms, self.nas_spaces, self.nas_estimators\n ):\n # TODO: initialize important parameters\n pass\n \"\"\"\n\n # pylint: disable=arguments-differ\n def fit(\n self,\n dataset,\n time_limit=-1,\n inplace=False,\n train_split=None,\n val_split=None,\n evaluation_method=\"infer\",\n seed=None,\n ) -> \"AutoGraphClassifier\":\n \"\"\"\n Fit current solver on given dataset.\n\n Parameters\n ----------\n dataset: torch_geometric.data.dataset.Dataset\n The multi-graph dataset needed to fit on.\n\n time_limit: int\n The time limit of the whole fit process (in seconds). If set below 0, will ignore\n time limit. Default ``-1``.\n\n inplace: bool\n Whether we process the given dataset in inplace manner. Default ``False``.\n Set it to True if you want to save memory by modifying the given dataset directly.\n\n train_split: float or int (Optional)\n The train ratio (in ``float``) or number (in ``int``) of dataset. If you want to use\n default train/val/test split in dataset, please set this to ``None``.\n Default ``None``.\n\n val_split: float or int (Optional)\n The validation ratio (in ``float``) or number (in ``int``) of dataset. If you want to\n use default train/val/test split in dataset, please set this to ``None``.\n Default ``None``.\n\n evaluation_method: (list of) str autogl.module.train.evaluation\n A (list of) evaluation method for current solver. If ``infer``, will automatically\n determine. Default ``infer``.\n\n seed: int (Optional)\n The random seed. If set to ``None``, will run everything at random.\n Default ``None``.\n\n Returns\n -------\n self: autogl.solver.AutoGraphClassifier\n A reference of current solver.\n \"\"\"\n\n set_seed(seed)\n\n if time_limit < 0:\n time_limit = 3600 * 24\n time_begin = time.time()\n\n # initialize leaderboard\n if evaluation_method == \"infer\":\n if hasattr(dataset, \"metric\"):\n evaluation_method = [dataset.metric]\n else:\n num_of_label = dataset.num_classes\n if num_of_label == 2:\n evaluation_method = [\"auc\"]\n else:\n evaluation_method = [\"acc\"]\n assert isinstance(evaluation_method, list)\n evaluator_list = get_feval(evaluation_method)\n\n self.leaderboard = LeaderBoard(\n [e.get_eval_name() for e in evaluator_list],\n {e.get_eval_name(): e.is_higher_better() for e in evaluator_list},\n )\n\n # set up the dataset\n if train_split is None and val_split is None:\n assert hasattr(dataset, \"train_split\") and hasattr(dataset, \"val_split\"), (\n \"The dataset has no default train/val split! \"\n \"Please manually pass train and val ratio.\"\n )\n LOGGER.info(\"Use the default train/val/test ratio in given dataset\")\n # if hasattr(dataset.train_split, \"n_splits\"):\n # cross_validation = True\n\n elif train_split is not None and val_split is not None:\n utils.graph_random_splits(dataset, train_split, val_split, seed=seed)\n else:\n LOGGER.error(\n \"Please set both train_split and val_split explicitly. Detect %s is None.\",\n \"train_split\" if train_split is None else \"val_split\",\n )\n raise ValueError(\n \"In consistent setting of train/val split. Detect {} is None.\".format(\n \"train_split\" if train_split is None else \"val_split\"\n )\n )\n\n # feature engineering\n if self.feature_module is not None:\n self.feature_module.fit(dataset.train_split)\n dataset = self.feature_module.transform(dataset, inplace=inplace)\n\n self.dataset = dataset\n assert dataset[0].x is not None, (\n \"Does not support fit on non node-feature dataset!\"\n \" Please add node features to dataset or specify feature engineers that generate\"\n \" node features.\"\n )\n\n # initialize graph networks\n self._init_graph_module(\n self.gml,\n num_features=dataset.num_node_features,\n num_classes=dataset.num_classes,\n feval=evaluator_list,\n device=self.runtime_device,\n loss=\"cross_entropy\" if not hasattr(dataset, \"loss\") else dataset.loss,\n num_graph_features=0\n if not hasattr(dataset.data, \"gf\")\n else dataset.data.gf.size(1),\n )\n\n # currently disabled\n \"\"\"\n self._init_nas_module(\n num_features=dataset.num_node_features,\n num_classes=dataset.num_classes,\n feval=evaluator_list,\n device=self.runtime_device,\n loss=\"cross_entropy\" if not hasattr(dataset, \"loss\") else dataset.loss,\n num_graph_features=0\n if not hasattr(dataset.data, \"gf\")\n else dataset.data.gf.size(1),\n )\n\n # neural architecture search\n if self.nas_algorithms is not None:\n # perform nas and add them to trainer list\n for algo, space, estimator in zip(\n self.nas_algorithms, self.nas_spaces, self.nas_estimators\n ):\n trainer = algo.search(space, self.dataset, estimator)\n self.graph_model_list.append(trainer)\n \"\"\"\n\n # train the models and tune hpo\n result_valid = []\n names = []\n for idx, model in enumerate(self.graph_model_list):\n if time_limit < 0:\n time_for_each_model = None\n else:\n time_for_each_model = (time_limit - time.time() + time_begin) / (\n len(self.graph_model_list) - idx\n )\n if self.hpo_module is None:\n model.initialize()\n model.train(dataset, True)\n optimized = model\n else:\n optimized, _ = self.hpo_module.optimize(\n trainer=model, dataset=dataset, time_limit=time_for_each_model\n )\n # to save memory, all the trainer derived will be mapped to cpu\n optimized.to(torch.device(\"cpu\"))\n name = str(optimized)\n names.append(name)\n performance_on_valid, _ = optimized.get_valid_score(return_major=False)\n result_valid.append(\n optimized.get_valid_predict_proba().detach().cpu().numpy()\n )\n self.leaderboard.insert_model_performance(\n name,\n dict(\n zip(\n [e.get_eval_name() for e in evaluator_list],\n performance_on_valid,\n )\n ),\n )\n self.trained_models[name] = optimized\n\n # fit the ensemble model\n if self.ensemble_module is not None:\n performance = self.ensemble_module.fit(\n result_valid,\n dataset.data.y[dataset.val_index].cpu().detach().numpy(),\n names,\n evaluator_list,\n n_classes=dataset.num_classes,\n )\n self.leaderboard.insert_model_performance(\n \"ensemble\",\n dict(zip([e.get_eval_name() for e in evaluator_list], performance)),\n )\n\n return self\n\n def fit_predict(\n self,\n dataset,\n time_limit=-1,\n inplace=False,\n train_split=None,\n val_split=None,\n evaluation_method=\"infer\",\n seed=None,\n use_ensemble=True,\n use_best=True,\n name=None,\n ) -> np.ndarray:\n \"\"\"\n Fit current solver on given dataset and return the predicted value.\n\n Parameters\n ----------\n dataset: torch_geometric.data.dataset.Dataset\n The dataset needed to fit on. This dataset must have only one graph.\n\n time_limit: int\n The time limit of the whole fit process (in seconds). If set below 0, will\n ignore time limit. Default ``-1``.\n\n inplace: bool\n Whether we process the given dataset in inplace manner. Default ``False``.\n Set it to True if you want to save memory by modifying the given dataset directly.\n\n train_split: float or int (Optional)\n The train ratio (in ``float``) or number (in ``int``) of dataset. If you want to\n use default train/val/test split in dataset, please set this to ``None``.\n Default ``None``.\n\n val_split: float or int (Optional)\n The validation ratio (in ``float``) or number (in ``int``) of dataset. If you want\n to use default train/val/test split in dataset, please set this to ``None``.\n Default ``None``.\n\n evaluation_method: (list of) str or autogl.module.train.evaluation\n A (list of) evaluation method for current solver. If ``infer``, will automatically\n determine. Default ``infer``.\n\n seed: int (Optional)\n The random seed. If set to ``None``, will run everything at random.\n Default ``None``.\n\n use_ensemble: bool\n Whether to use ensemble to do the predict. Default ``True``.\n\n use_best: bool\n Whether to use the best single model to do the predict. Will only be effective when\n ``use_ensemble`` is ``False``. Default ``True``.\n\n name: str or None\n The name of model used to predict. Will only be effective when ``use_ensemble`` and\n ``use_best`` both are ``False``. Default ``None``.\n\n Returns\n -------\n result: np.ndarray\n An array of shape ``(N,)``, where ``N`` is the number of test nodes. The prediction\n on given dataset.\n \"\"\"\n self.fit(\n dataset=dataset,\n time_limit=time_limit,\n inplace=inplace,\n train_split=train_split,\n val_split=val_split,\n evaluation_method=evaluation_method,\n seed=seed,\n )\n return self.predict(\n dataset=dataset,\n inplaced=inplace,\n inplace=inplace,\n use_ensemble=use_ensemble,\n use_best=use_best,\n name=name,\n )\n\n def predict_proba(\n self,\n dataset=None,\n inplaced=False,\n inplace=False,\n use_ensemble=True,\n use_best=True,\n name=None,\n mask=\"test\",\n ) -> np.ndarray:\n \"\"\"\n Predict the node probability.\n\n Parameters\n ----------\n dataset: torch_geometric.data.dataset.Dataset or None\n The dataset needed to predict. If ``None``, will use the processed dataset\n passed to ``fit()`` instead. Default ``None``.\n\n inplaced: bool\n Whether the given dataset is processed. Only be effective when ``dataset``\n is not ``None``. If you pass the dataset to ``fit()`` with ``inplace=True``,\n and you pass the dataset again to this method, you should set this argument\n to ``True``. Otherwise ``False``. Default ``False``.\n\n inplace: bool\n Whether we process the given dataset in inplace manner. Default ``False``.\n Set it to True if you want to save memory by modifying the given dataset directly.\n\n use_ensemble: bool\n Whether to use ensemble to do the predict. Default ``True``.\n\n use_best: bool\n Whether to use the best single model to do the predict. Will only be effective when\n ``use_ensemble`` is ``False``. Default ``True``.\n\n name: str or None\n The name of model used to predict. Will only be effective when ``use_ensemble`` and\n ``use_best`` both are ``False``. Default ``None``.\n\n mask: str\n The data split to give prediction on. Default ``test``.\n\n Returns\n -------\n result: np.ndarray\n An array of shape ``(N,C,)``, where ``N`` is the number of test nodes and ``C`` is\n the number of classes. The prediction on given dataset.\n \"\"\"\n if dataset is None:\n dataset = self.dataset\n elif not inplaced:\n if self.feature_module is not None:\n dataset = self.feature_module.transform(dataset, inplace=inplace)\n\n if use_ensemble:\n LOGGER.info(\"Ensemble argument on, will try using ensemble model.\")\n\n if not use_ensemble and use_best:\n LOGGER.info(\n \"Ensemble argument off and best argument on, will try using best model.\"\n )\n\n if (use_ensemble and self.ensemble_module is not None) or (\n not use_best and name == \"ensemble\"\n ):\n # we need to get all the prediction of every model trained\n predict_result = []\n names = []\n for model_name in self.trained_models:\n predict_result.append(\n self._predict_proba_by_name(dataset, model_name, mask)\n )\n names.append(model_name)\n return self.ensemble_module.ensemble(predict_result, names)\n\n if use_ensemble and self.ensemble_module is None:\n LOGGER.warning(\n \"Cannot use ensemble because no ensebmle module is given. \"\n \"Will use best model instead.\"\n )\n\n if use_best or (use_ensemble and self.ensemble_module is None):\n # just return the best model we have found\n best_model_name = self.leaderboard.get_best_model()\n return self._predict_proba_by_name(dataset, best_model_name, mask)\n\n if name is not None:\n # return model performance by name\n return self._predict_proba_by_name(dataset, name, mask)\n\n LOGGER.error(\n \"No model name is given while ensemble and best arguments are off.\"\n )\n raise ValueError(\n \"You need to specify a model name if you do not want use ensemble and best model.\"\n )\n\n def _predict_proba_by_name(self, dataset, name, mask):\n self.trained_models[name].to(self.runtime_device)\n predicted = (\n self.trained_models[name]\n .predict_proba(dataset, mask=mask)\n .detach()\n .cpu()\n .numpy()\n )\n self.trained_models[name].to(torch.device(\"cpu\"))\n return predicted\n\n def predict(\n self,\n dataset=None,\n inplaced=False,\n inplace=False,\n use_ensemble=True,\n use_best=True,\n name=None,\n mask=\"test\",\n ) -> np.ndarray:\n \"\"\"\n Predict the node class number.\n\n Parameters\n ----------\n dataset: torch_geometric.data.dataset.Dataset or None\n The dataset needed to predict. If ``None``, will use the processed dataset passed\n to ``fit()`` instead. Default ``None``.\n\n inplaced: bool\n Whether the given dataset is processed. Only be effective when ``dataset``\n is not ``None``. If you pass the dataset to ``fit()`` with ``inplace=True``, and\n you pass the dataset again to this method, you should set this argument to ``True``.\n Otherwise ``False``. Default ``False``.\n\n inplace: bool\n Whether we process the given dataset in inplace manner. Default ``False``.\n Set it to True if you want to save memory by modifying the given dataset directly.\n\n use_ensemble: bool\n Whether to use ensemble to do the predict. Default ``True``.\n\n use_best: bool\n Whether to use the best single model to do the predict. Will only be effective\n when ``use_ensemble`` is ``False``. Default ``True``.\n\n name: str or None\n The name of model used to predict. Will only be effective when ``use_ensemble``\n and ``use_best`` both are ``False``. Default ``None``.\n\n Returns\n -------\n result: np.ndarray\n An array of shape ``(N,)``, where ``N`` is the number of test nodes.\n The prediction on given dataset.\n \"\"\"\n proba = self.predict_proba(\n dataset, inplaced, inplace, use_ensemble, use_best, name, mask\n )\n return np.argmax(proba, axis=1)\n\n @classmethod\n def from_config(cls, path_or_dict, filetype=\"auto\") -> \"AutoGraphClassifier\":\n \"\"\"\n Load solver from config file.\n\n You can use this function to directly load a solver from predefined config dict\n or config file path. Currently, only support file type of ``json`` or ``yaml``,\n if you pass a path.\n\n Parameters\n ----------\n path_or_dict: str or dict\n The path to the config file or the config dictionary object\n\n filetype: str\n The filetype the given file if the path is specified. Currently only support\n ``json`` or ``yaml``. You can set to ``auto`` to automatically detect the file\n type (from file name). Default ``auto``.\n\n Returns\n -------\n solver: autogl.solver.AutoGraphClassifier\n The solver that is created from given file or dictionary.\n \"\"\"\n assert filetype in [\"auto\", \"yaml\", \"json\"], (\n \"currently only support yaml file or json file type, but get type \"\n + filetype\n )\n if isinstance(path_or_dict, str):\n if filetype == \"auto\":\n if path_or_dict.endswith(\".yaml\") or path_or_dict.endswith(\".yml\"):\n filetype = \"yaml\"\n elif path_or_dict.endswith(\".json\"):\n filetype = \"json\"\n else:\n LOGGER.error(\n \"cannot parse the type of the given file name, \"\n \"please manually set the file type\"\n )\n raise ValueError(\n \"cannot parse the type of the given file name, \"\n \"please manually set the file type\"\n )\n if filetype == \"yaml\":\n path_or_dict = yaml.load(\n open(path_or_dict, \"r\").read(), Loader=yaml.FullLoader\n )\n else:\n path_or_dict = json.load(open(path_or_dict, \"r\"))\n\n # load the dictionary\n path_or_dict = deepcopy(path_or_dict)\n solver = cls(None, [], None, None)\n fe_list = path_or_dict.pop(\"feature\", None)\n if fe_list is not None:\n fe_list_ele = []\n for feature_engineer in fe_list:\n name = feature_engineer.pop(\"name\")\n if name is not None:\n fe_list_ele.append(FEATURE_DICT[name](**feature_engineer))\n if fe_list_ele != []:\n solver.set_feature_module(fe_list_ele)\n\n models = path_or_dict.pop(\"models\", [{\"name\": \"gin\"}, {\"name\": \"topkpool\"}])\n model_hp_space = [\n _parse_hp_space(model.pop(\"hp_space\", None)) for model in models\n ]\n model_list = [\n _initialize_single_model(model.pop(\"name\"), model) for model in models\n ]\n\n trainer = path_or_dict.pop(\"trainer\", None)\n default_trainer = \"GraphClassificationFull\"\n trainer_space = None\n if isinstance(trainer, dict):\n # global default\n default_trainer = trainer.pop(\"name\", \"GraphClassificationFull\")\n trainer_space = _parse_hp_space(trainer.pop(\"hp_space\", None))\n default_kwargs = {\"num_features\": None, \"num_classes\": None}\n default_kwargs.update(trainer)\n default_kwargs[\"init\"] = False\n for i in range(len(model_list)):\n model = model_list[i]\n trainer_wrapper = TRAINER_DICT[default_trainer](\n model=model, **default_kwargs\n )\n model_list[i] = trainer_wrapper\n elif isinstance(trainer, list):\n # sequential trainer definition\n assert len(trainer) == len(\n model_list\n ), \"The number of trainer and model does not match\"\n trainer_space = []\n for i in range(len(model_list)):\n train, model = trainer[i], model_list[i]\n default_trainer = train.pop(\"name\", \"GraphClassificationFull\")\n trainer_space.append(_parse_hp_space(train.pop(\"hp_space\", None)))\n default_kwargs = {\"num_features\": None, \"num_classes\": None}\n default_kwargs.update(train)\n default_kwargs[\"init\"] = False\n trainer_wrap = TRAINER_DICT[default_trainer](\n model=model, **default_kwargs\n )\n model_list[i] = trainer_wrap\n\n solver.set_graph_models(\n model_list, default_trainer, trainer_space, model_hp_space\n )\n\n hpo_dict = path_or_dict.pop(\"hpo\", {\"name\": \"anneal\"})\n if hpo_dict is not None:\n name = hpo_dict.pop(\"name\")\n solver.set_hpo_module(name, **hpo_dict)\n\n ensemble_dict = path_or_dict.pop(\"ensemble\", {\"name\": \"voting\"})\n if ensemble_dict is not None:\n name = ensemble_dict.pop(\"name\")\n solver.set_ensemble_module(name, **ensemble_dict)\n\n return solver\n"
] | [
[
"torch.nn.functional.softmax"
],
[
"torch.device",
"numpy.argmax"
]
] |
kumagai-group/vise | [
"8adfe61ad8f31767ec562f02f271e2495f357cd4",
"8adfe61ad8f31767ec562f02f271e2495f357cd4"
] | [
"vise/analyzer/dielectric_function.py",
"vise/util/plotly_util.py"
] | [
"# -*- coding: utf-8 -*-\n# Copyright (c) 2020. Distributed under the terms of the MIT License.\nfrom dataclasses import dataclass\nfrom math import sqrt, pi\nfrom typing import List\n\nimport numpy as np\nfrom monty.json import MSONable\nfrom tqdm import tqdm\nfrom vise.util.mix_in import ToJsonFileMixIn\nfrom scipy.constants import physical_constants as pc\n\neV_to_inv_cm = pc[\"electron volt-inverse meter relationship\"][0] / 100\n\n\ndef diele_func_to_coeff(freq, real, imag):\n return (2 * sqrt(2) * pi * sqrt(sqrt(real ** 2 + imag ** 2) - real)\n * freq * eV_to_inv_cm)\n\n\n@dataclass\nclass DieleFuncData(MSONable, ToJsonFileMixIn):\n energies: List[float] # in eV\n diele_func_real: List[List[float]] # [xx, yy, zz, xy, yz, xz]\n diele_func_imag: List[List[float]] # [xx, yy, zz, xy, yz, xz]\n band_gap: float # in eV\n\n @property\n def ave_absorption_coeff(self):\n reals = [sum(self.diele_func_real[i][:3]) / 3\n for i in range(len(self.energies))]\n imags = [sum(self.diele_func_imag[i][:3]) / 3\n for i in range(len(self.energies))]\n return [diele_func_to_coeff(freq, real, imag)\n for freq, real, imag in zip(self.energies, reals, imags)]\n\n def target_coeff_min_e(self, target_coeff: float = 10**4):\n for e, coeff in zip(self.energies, self.ave_absorption_coeff):\n if coeff > target_coeff:\n return e\n return None\n\n\ndef make_shifted_diele_func(diele_func_data: DieleFuncData,\n original_band_gap: float,\n shift: float) -> DieleFuncData:\n imag = imag_shift(diele_func_data.diele_func_imag,\n diele_func_data.energies,\n original_band_gap + shift, shift)\n real = kramers_kronig_trans(imag, diele_func_data.energies)\n return DieleFuncData(diele_func_data.energies,\n real.tolist(),\n imag.tolist(),\n original_band_gap + shift)\n\n\ndef imag_shift(diele_func_imag: List[List[float]],\n energies: List[float],\n band_gap: float,\n shift: float) -> np.ndarray:\n energies = np.array(energies)\n assert shift > 0\n result = []\n for energy_grid in energies:\n old_e = energy_grid - shift\n right_idx = np.argwhere(energies > old_e)[0][0]\n left_e, right_e = energies[right_idx - 1], energies[right_idx]\n # linear interpolation\n left_ratio = (right_e - old_e) / (right_e - left_e)\n\n inner_result = []\n for imag_idx in range(6):\n if energy_grid < band_gap:\n inner_result.append(0.0)\n else:\n old_diele = \\\n diele_func_imag[right_idx - 1][imag_idx] * left_ratio + \\\n diele_func_imag[right_idx][imag_idx] * (1 - left_ratio)\n inner_result.append(\n old_diele * (energy_grid - shift) / energy_grid)\n\n result.append(inner_result)\n\n return np.array(result)\n\n\ndef kramers_kronig_trans(diele_func_imag: np.array,\n energies: List[float],\n ita: float = 0.01) -> np.ndarray:\n mesh = energies[1] - energies[0]\n result = []\n ee2ss = [[e ** 2 - energy_grid ** 2 for e in energies]\n for energy_grid in energies]\n for imag_idx in tqdm(range(6)):\n imags = diele_func_imag[:, imag_idx]\n if imag_idx == 0 or \\\n (imag_idx > 0\n and np.allclose(\n imags, diele_func_imag[:, imag_idx - 1]) is False):\n if np.count_nonzero(imags) == 0:\n inner_result = [0.0] * len(energies)\n else:\n inner_result = []\n for ee2s in ee2ss:\n integrals = [e * imag * ee2 / (ee2 ** 2 + ita ** 2)\n for e, ee2, imag in zip(energies, ee2s, imags)]\n integral = sum(integrals) * mesh * 2 / pi\n if imag_idx < 3:\n integral += 1\n inner_result.append(integral)\n\n result.append(inner_result)\n\n return np.array(result).T",
"# Copyright (c) 2020. Distributed under the terms of the MIT License.\n\nimport numpy as np\nfrom numpy import concatenate, clip, dot, arctan2\nfrom numpy.linalg import det\n\n\ndef sort_coords(coords: np.ndarray) -> np.ndarray:\n \"\"\"Sort coordinates based on the angle with first coord from the center.\n\n Args:\n coords (np.ndarray):\n Coordinates to be sorted. The format of coords is as follows.\n np.array([[x1, y1, z1], [x2, y2, z2], [x3, y3, z3]]\n\n Returns:\n np.ndarray for sorted coordinates.\n \"\"\"\n if len(coords[0]) != 3:\n raise ValueError(\"Only valid for 3D vector\")\n\n center = np.average(coords, axis=0)\n relative_coords = coords - center\n external_prod = np.cross(relative_coords[0], relative_coords[1])\n\n # Skip parallel vectors.\n if abs(np.linalg.norm(external_prod)) < 1e-8 and len(relative_coords) > 2:\n external_prod = np.cross(relative_coords[0], relative_coords[2])\n normal_to_12_plane = external_prod / np.linalg.norm(external_prod)\n\n v0 = relative_coords[0] / np.linalg.norm(relative_coords[0])\n\n def angle_between_v0(index: int) -> float:\n \"\"\"\n Args:\n index (int): index of coords.\n\n Returns (float):\n Angle between rays from the center to rel_coords[0] and\n rel_coords[int].\n \"\"\"\n v = relative_coords[index] / np.linalg.norm(relative_coords[index])\n matrix = concatenate(([v0], [v], [normal_to_12_plane]), axis=0)\n determinant = det(matrix)\n angle = arctan2(clip(dot(v0, v), -1.0, 1.0), determinant)\n return angle\n\n indices = [i for i in range(len(coords))]\n indices.sort(key=angle_between_v0)\n return coords[indices]\n\n\ndef make_triangles(vertices):\n x = [v[0] for v in vertices]\n y = [v[1] for v in vertices]\n z = [v[2] for v in vertices]\n n_vertices = len(x)\n i = [0] * (n_vertices - 2)\n j = [x for x in range(1, n_vertices - 1)]\n k = [x for x in range(2, n_vertices)]\n return dict(x=x, y=y, z=z, i=i, j=j, k=k)"
] | [
[
"numpy.allclose",
"numpy.array",
"numpy.count_nonzero",
"numpy.argwhere"
],
[
"numpy.concatenate",
"numpy.linalg.norm",
"numpy.dot",
"numpy.linalg.det",
"numpy.average",
"numpy.cross"
]
] |
RobinCondat/pytorch-retinanet | [
"14a2085cd3785a667454898dc65f5324b1b9c6b8"
] | [
"retinanet/losses_vehicle.py"
] | [
"import numpy as np\nimport torch\nimport torch.nn as nn\nfrom retinanet.config_experiment_2 import INDEXES_MIX, VEHICLE_INDEXES\n\ndef calc_iou(a, b):\n area = (b[:, 2] - b[:, 0]) * (b[:, 3] - b[:, 1])\n\n iw = torch.min(torch.unsqueeze(a[:, 2], dim=1), b[:, 2]) - torch.max(torch.unsqueeze(a[:, 0], 1), b[:, 0])\n ih = torch.min(torch.unsqueeze(a[:, 3], dim=1), b[:, 3]) - torch.max(torch.unsqueeze(a[:, 1], 1), b[:, 1])\n\n iw = torch.clamp(iw, min=0)\n ih = torch.clamp(ih, min=0)\n\n ua = torch.unsqueeze((a[:, 2] - a[:, 0]) * (a[:, 3] - a[:, 1]), dim=1) + area - iw * ih\n\n ua = torch.clamp(ua, min=1e-8)\n\n intersection = iw * ih\n\n IoU = intersection / ua\n\n return IoU\n\ndef cal_ioa(a, b):\n # Intersection over Area (for ignore regions)\n area = torch.unsqueeze((a[:, 2] - a[:, 0]) * (a[:, 3] - a[:, 1]),dim=1)\n area = torch.clamp(area, min=1e-8)\n\n iw = torch.min(torch.unsqueeze(a[:, 2], dim=1), b[:, 2]) - torch.max(torch.unsqueeze(a[:, 0], 1), b[:, 0])\n ih = torch.min(torch.unsqueeze(a[:, 3], dim=1), b[:, 3]) - torch.max(torch.unsqueeze(a[:, 1], 1), b[:, 1])\n\n iw = torch.clamp(iw, min=0)\n ih = torch.clamp(ih, min=0)\n\n intersection = iw * ih\n\n IoA = intersection / area\n\n return IoA\n\n\nclass FocalLoss(nn.Module):\n #def __init__(self):\n\n def forward(self, classifications, regressions, anchors, annotations, dataset, ignore_index=None, merge_index=None):\n\n classes_from_other_datasets = [i for i in range(classifications.shape[-1]+1) if i not in INDEXES_MIX[dataset]]\n alpha = 0.25\n gamma = 2.0\n batch_size = classifications.shape[0]\n classification_losses = []\n regression_losses = []\n\n anchor = anchors[0, :, :]\n num_anchors = anchor.shape[0]\n\n anchor_widths = anchor[:, 2] - anchor[:, 0]\n anchor_heights = anchor[:, 3] - anchor[:, 1]\n anchor_ctr_x = anchor[:, 0] + 0.5 * anchor_widths\n anchor_ctr_y = anchor[:, 1] + 0.5 * anchor_heights\n if merge_index is not None:\n classifications = torch.cat((classifications,torch.zeros((classifications.shape[0],classifications.shape[1],1)).cuda()),2)\n print(classifications.shape)\n for j in range(batch_size):\n classification = classifications[j, :, :]\n regression = regressions[j, :, :]\n\n bbox_annotation = annotations[j, :, :]\n bbox_annotation = bbox_annotation[bbox_annotation[:, 4] != -1]\n \n # Merge vehicle detections in vehicle class\n if merge_index is not None:\n if merge_index not in classes_from_other_datasets:\n #print(torch.max(classification[:,VEHICLE_INDEXES], dim=1)[0].shape)\n classification[:,merge_index] = torch.max(classification[:,VEHICLE_INDEXES], dim=1)[0]\n\n # Ignore class from other datasets\n classification[:,classes_from_other_datasets]=0\n\n classification = torch.clamp(classification, 1e-4, 1.0 - 1e-4)\n\n if bbox_annotation.shape[0] == 0:\n if torch.cuda.is_available():\n alpha_factor = torch.ones(classification.shape).cuda() * alpha\n\n alpha_factor = 1. - alpha_factor\n focal_weight = classification\n\n focal_weight = alpha_factor * torch.pow(focal_weight, gamma)\n\n bce = -(torch.log(1.0 - classification))\n\n cls_loss = focal_weight * bce\n classification_losses.append(cls_loss.sum())\n regression_losses.append(torch.tensor(0).float().cuda())\n \n else:\n alpha_factor = torch.ones(classification.shape) * alpha\n\n alpha_factor = 1. - alpha_factor\n focal_weight = classification\n\n focal_weight = alpha_factor * torch.pow(focal_weight, gamma)\n\n bce = -(torch.log(1.0 - classification))\n\n cls_loss = focal_weight * bce\n classification_losses.append(cls_loss.sum())\n regression_losses.append(torch.tensor(0).float())\n \n continue\n\n # Filter ignore class (via ignore_index)\n if ignore_index is not None:\n # On sépare ici les annotations en 2 objets : \n # - bbox_annotation (pour tous les objets à détecter) \n # - ignore_annotation (pour toutes les régions à ignorer)\n ignore_annotation = bbox_annotation[bbox_annotation[:,4] == ignore_index]\n bbox_annotation = bbox_annotation[bbox_annotation[:,4] != ignore_index]\n\n if bbox_annotation.shape[0] != 0:\n IoU = calc_iou(anchors[0, :, :], bbox_annotation[:, :4]) # num_anchors x num_annotations_to_detect\n IoU_max, IoU_argmax = torch.max(IoU, dim=1) # num_anchors x 1\n else:\n IoU_max = None\n IoU_argmax = None\n \n if ignore_index is not None:\n # On calcule ici l'intersection over area : \n # tous les anchors ayant une IoA avec une région à ignorer supérieure à 0.5 seront ignorées pour la suite\n if ignore_annotation.shape[0] !=0:\n IoA = cal_ioa(anchors[0, :, :], ignore_annotation[:, :4]) # num_anchors x num_annotations_to_ignore \n IoA_max, IoA_argmax = torch.max(IoA, dim=1) # num_anchors x 1\n else:\n IoA_max = None\n IoA_argmax = None\n \n # compute the loss for classification\n targets = torch.ones(classification.shape) * -1\n\n if torch.cuda.is_available():\n targets = targets.cuda()\n\n if IoU_max is not None:\n targets[torch.lt(IoU_max, 0.4), :] = 0\n else:\n targets = targets*0\n \n if ignore_index is not None:\n if IoA_max is not None:\n ignore_indices = torch.ge(IoA_max, 0.5)\n else:\n ignore_indices = (torch.ones((num_anchors)) * 0).type(torch.ByteTensor)\n if IoU_max is not None:\n positive_indices = torch.ge(IoU_max, 0.5)\n num_positive_anchors = positive_indices.sum()\n \n else:\n positive_indices = (torch.ones((num_anchors)) * 0).type(torch.ByteTensor)\n num_positive_anchors = torch.tensor(0)\n \n if ignore_index is not None:\n if ignore_indices is not None:\n targets[ignore_indices, :] = -1\n \n if IoU_argmax is not None:\n assigned_annotations = bbox_annotation[IoU_argmax, :]\n targets[positive_indices, :] = 0\n targets[positive_indices, assigned_annotations[positive_indices, 4].long()] = 1\n \n if torch.cuda.is_available():\n alpha_factor = torch.ones(targets.shape).cuda() * alpha\n else:\n alpha_factor = torch.ones(targets.shape) * alpha\n\n alpha_factor = torch.where(torch.eq(targets, 1.), alpha_factor, 1. - alpha_factor)\n focal_weight = torch.where(torch.eq(targets, 1.), 1. - classification, classification)\n \n focal_weight = alpha_factor * torch.pow(focal_weight, gamma)\n\n bce = -(targets * torch.log(classification) + (1.0 - targets) * torch.log(1.0 - classification))\n\n cls_loss = focal_weight * bce\n\n if torch.cuda.is_available():\n cls_loss = torch.where(torch.ne(targets, -1.0), cls_loss, torch.zeros(cls_loss.shape).cuda())\n else:\n cls_loss = torch.where(torch.ne(targets, -1.0), cls_loss, torch.zeros(cls_loss.shape))\n classification_losses.append(cls_loss.sum()/torch.clamp(num_positive_anchors.float(), min=1.0))\n \n # compute the loss for regression\n\n if num_positive_anchors > 0:\n assigned_annotations = assigned_annotations[positive_indices, :]\n\n anchor_widths_pi = anchor_widths[positive_indices]\n anchor_heights_pi = anchor_heights[positive_indices]\n anchor_ctr_x_pi = anchor_ctr_x[positive_indices]\n anchor_ctr_y_pi = anchor_ctr_y[positive_indices]\n\n gt_widths = assigned_annotations[:, 2] - assigned_annotations[:, 0]\n gt_heights = assigned_annotations[:, 3] - assigned_annotations[:, 1]\n gt_ctr_x = assigned_annotations[:, 0] + 0.5 * gt_widths\n gt_ctr_y = assigned_annotations[:, 1] + 0.5 * gt_heights\n\n # clip widths to 1\n gt_widths = torch.clamp(gt_widths, min=1)\n gt_heights = torch.clamp(gt_heights, min=1)\n\n targets_dx = (gt_ctr_x - anchor_ctr_x_pi) / anchor_widths_pi\n targets_dy = (gt_ctr_y - anchor_ctr_y_pi) / anchor_heights_pi\n targets_dw = torch.log(gt_widths / anchor_widths_pi)\n targets_dh = torch.log(gt_heights / anchor_heights_pi)\n\n targets = torch.stack((targets_dx, targets_dy, targets_dw, targets_dh))\n targets = targets.t()\n\n if torch.cuda.is_available():\n targets = targets/torch.Tensor([[0.1, 0.1, 0.2, 0.2]]).cuda()\n else:\n targets = targets/torch.Tensor([[0.1, 0.1, 0.2, 0.2]])\n\n negative_indices = 1 + (~positive_indices)\n\n regression_diff = torch.abs(targets - regression[positive_indices, :])\n\n regression_loss = torch.where(\n torch.le(regression_diff, 1.0 / 9.0),\n 0.5 * 9.0 * torch.pow(regression_diff, 2),\n regression_diff - 0.5 / 9.0\n )\n regression_losses.append(regression_loss.mean())\n else:\n if torch.cuda.is_available():\n regression_losses.append(torch.tensor(0).float().cuda())\n else:\n regression_losses.append(torch.tensor(0).float())\n\n return torch.stack(classification_losses).mean(dim=0, keepdim=True), torch.stack(regression_losses).mean(dim=0, keepdim=True)\n\n \n"
] | [
[
"torch.zeros",
"torch.stack",
"torch.eq",
"torch.max",
"torch.ne",
"torch.le",
"torch.clamp",
"torch.ones",
"torch.unsqueeze",
"torch.abs",
"torch.cuda.is_available",
"torch.tensor",
"torch.lt",
"torch.log",
"torch.ge",
"torch.Tensor",
"torch.pow"
]
] |
PeterouZh/PyTorch-StudioGAN | [
"faef6048d25dadee4fa31b2955f16f7d1ca8e1e2"
] | [
"src/main.py"
] | [
"# PyTorch StudioGAN: https://github.com/POSTECH-CVLab/PyTorch-StudioGAN\n# The MIT License (MIT)\n# See license file or visit https://github.com/POSTECH-CVLab/PyTorch-StudioGAN for details\n\n# src/main.py\n\n\nimport json\nimport os\nimport sys\nimport random\nimport warnings\nfrom argparse import ArgumentParser\n\nfrom utils.misc import *\nfrom utils.make_hdf5 import make_hdf5\nfrom utils.log import make_run_name\nfrom loader import prepare_train_eval\n\nimport torch\nfrom torch.backends import cudnn\nimport torch.multiprocessing as mp\n\n\n\nRUN_NAME_FORMAT = (\n \"{framework}-\"\n \"{phase}-\"\n \"{timestamp}\"\n)\n\n\ndef main():\n parser = ArgumentParser(add_help=False)\n parser.add_argument('-c', '--config_path', type=str, default='./src/configs/CIFAR10/ContraGAN.json')\n parser.add_argument('--checkpoint_folder', type=str, default=None)\n parser.add_argument('-current', '--load_current', action='store_true', help='whether you load the current or best checkpoint')\n parser.add_argument('--log_output_path', type=str, default=None)\n\n parser.add_argument('-DDP', '--distributed_data_parallel', action='store_true')\n parser.add_argument('-n', '--nodes', default=1, type=int, metavar='N')\n parser.add_argument('-nr', '--nr', default=0, type=int, help='ranking within the nodes')\n\n parser.add_argument('--seed', type=int, default=-1, help='seed for generating random numbers')\n parser.add_argument('--num_workers', type=int, default=8, help='')\n parser.add_argument('-sync_bn', '--synchronized_bn', action='store_true', help='whether turn on synchronized batchnorm')\n parser.add_argument('-mpc', '--mixed_precision', action='store_true', help='whether turn on mixed precision training')\n parser.add_argument('-LARS', '--LARS_optimizer', action='store_true', help='whether turn on LARS optimizer')\n parser.add_argument('-rm_API', '--disable_debugging_API', action='store_true', help='whether disable pytorch autograd debugging mode')\n\n parser.add_argument('--reduce_train_dataset', type=float, default=1.0, help='control the number of train dataset')\n parser.add_argument('--truncated_factor', type=float, default=-1.0, help='factor for truncation trick')\n parser.add_argument('-stat_otf', '--bn_stat_OnTheFly', action='store_true', help='when evaluating, use the statistics of a batch')\n parser.add_argument('-std_stat', '--standing_statistics', action='store_true')\n parser.add_argument('--standing_step', type=int, default=-1, help='# of steps for accumulation batchnorm')\n parser.add_argument('--freeze_layers', type=int, default=-1, help='# of layers for freezing discriminator')\n\n parser.add_argument('-l', '--load_all_data_in_memory', action='store_true')\n parser.add_argument('-t', '--train', action='store_true')\n parser.add_argument('-e', '--eval', action='store_true')\n parser.add_argument('-s', '--save_images', action='store_true')\n parser.add_argument('-iv', '--image_visualization', action='store_true', help='select whether conduct image visualization')\n parser.add_argument('-knn', '--k_nearest_neighbor', action='store_true', help='select whether conduct k-nearest neighbor analysis')\n parser.add_argument('-itp', '--interpolation', action='store_true', help='whether conduct interpolation analysis')\n parser.add_argument('-fa', '--frequency_analysis', action='store_true', help='whether conduct frequency analysis')\n parser.add_argument('-tsne', '--tsne_analysis', action='store_true', help='whether conduct tsne analysis')\n parser.add_argument('--nrow', type=int, default=10, help='number of rows to plot image canvas')\n parser.add_argument('--ncol', type=int, default=8, help='number of cols to plot image canvas')\n\n parser.add_argument('--print_every', type=int, default=100, help='control log interval')\n parser.add_argument('--save_every', type=int, default=2000, help='control evaluation and save interval')\n parser.add_argument('--eval_type', type=str, default='test', help='[train/valid/test]')\n\n from template_lib.v2.config_cfgnode import update_parser_defaults_from_yaml, global_cfg\n update_parser_defaults_from_yaml(parser=parser)\n args = parser.parse_args()\n\n if not args.train and \\\n not args.eval and \\\n not args.save_images and \\\n not args.image_visualization and \\\n not args.k_nearest_neighbor and \\\n not args.interpolation and \\\n not args.frequency_analysis and \\\n not args.tsne_analysis:\n parser.print_help(sys.stderr)\n sys.exit(1)\n\n if args.config_path is not None:\n with open(args.config_path) as f:\n model_configs = json.load(f)\n train_configs = vars(args)\n else:\n raise NotImplementedError\n\n hdf5_path_train = make_hdf5(model_configs['data_processing'], train_configs, mode=\"train\") \\\n if train_configs['load_all_data_in_memory'] else None\n\n if train_configs['seed'] == -1:\n train_configs['seed'] = random.randint(1,4096)\n cudnn.benchmark, cudnn.deterministic = True, False\n else:\n cudnn.benchmark, cudnn.deterministic = False, True\n\n fix_all_seed(train_configs['seed'])\n gpus_per_node, rank = torch.cuda.device_count(), torch.cuda.current_device()\n world_size = gpus_per_node*train_configs['nodes']\n if world_size == 1:\n warnings.warn('You have chosen a specific GPU. This will completely disable data parallelism.')\n\n run_name = make_run_name(RUN_NAME_FORMAT, framework=train_configs['config_path'].split('/')[-1][:-5], phase='train')\n if train_configs['disable_debugging_API']: torch.autograd.set_detect_anomaly(False)\n check_flags(train_configs, model_configs, world_size)\n\n if train_configs['distributed_data_parallel'] and world_size > 1:\n print(\"Train the models through DistributedDataParallel (DDP) mode.\")\n mp.spawn(prepare_train_eval, nprocs=gpus_per_node, args=(gpus_per_node, world_size, run_name,\n train_configs, model_configs, hdf5_path_train))\n else:\n prepare_train_eval(rank, gpus_per_node, world_size, run_name, train_configs, model_configs, hdf5_path_train=hdf5_path_train)\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"torch.cuda.current_device",
"torch.autograd.set_detect_anomaly",
"torch.multiprocessing.spawn",
"torch.cuda.device_count"
]
] |
anigasan/tensorflow | [
"5b780b4983007661ca479bf4d7ed9a260d8ce43f"
] | [
"tensorflow/lite/python/convert.py"
] | [
"# Lint as: python2, python3\n# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Converts a frozen graph into a TFLite FlatBuffer.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport enum # pylint: disable=g-bad-import-order\nimport os as _os\nimport platform as _platform\nimport subprocess as _subprocess\nimport tempfile as _tempfile\n\nimport six\nfrom six.moves import map\n\nfrom tensorflow.lite.python import lite_constants\nfrom tensorflow.lite.python import util\nfrom tensorflow.lite.python import wrap_toco\nfrom tensorflow.lite.toco import model_flags_pb2 as _model_flags_pb2\nfrom tensorflow.lite.toco import toco_flags_pb2 as _toco_flags_pb2\nfrom tensorflow.lite.toco import types_pb2 as _types_pb2\nfrom tensorflow.python.platform import resource_loader as _resource_loader\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util.tf_export import tf_export as _tf_export\n\n\n# Find the toco_from_protos binary using the resource loader if using from\n# bazel, otherwise we are in a pip where console_scripts already has\n# the toco_from_protos tool.\nif lite_constants.EXPERIMENTAL_USE_TOCO_API_DIRECTLY:\n _toco_from_proto_bin = \"\"\nelse:\n _toco_from_proto_bin = _resource_loader.get_path_to_datafile(\n \"../toco/python/toco_from_protos\")\n\nif _toco_from_proto_bin and not _os.path.exists(_toco_from_proto_bin):\n _toco_from_proto_bin = \"toco_from_protos\"\n\n\ndef _try_convert_to_unicode(output):\n if output is None:\n return u\"\"\n\n if isinstance(output, bytes):\n try:\n return six.ensure_text(output)\n except UnicodeDecodeError:\n pass\n return output\n\n\n@_tf_export(\"lite.OpsSet\")\nclass OpsSet(enum.Enum):\n \"\"\"Enum class defining the sets of ops available to generate TFLite models.\n\n WARNING: Experimental interface, subject to change.\n \"\"\"\n # Convert model using TensorFlow Lite builtin ops.\n TFLITE_BUILTINS = \"TFLITE_BUILTINS\"\n\n # Convert model using TensorFlow ops. Not all TensorFlow ops are available.\n # WARNING: Experimental interface, subject to change.\n SELECT_TF_OPS = \"SELECT_TF_OPS\"\n\n # Convert model using only TensorFlow Lite quantized int8 operations.\n # Specifying this will throw an error for operations that do not yet have\n # quantized implementations.\n TFLITE_BUILTINS_INT8 = \"TFLITE_BUILTINS_INT8\"\n\n def __str__(self):\n return self.value\n\n @staticmethod\n def get_options():\n \"\"\"Returns a list of OpsSet options as a list of strings.\"\"\"\n return [str(option) for option in list(OpsSet)]\n\n\nclass ConverterError(Exception):\n \"\"\"Raised when an error occurs during model conversion.\"\"\"\n pass\n\n\ndef toco_convert_protos(model_flags_str,\n toco_flags_str,\n input_data_str,\n debug_info_str=None,\n enable_mlir_converter=False):\n \"\"\"Convert `input_data_str` according to model and toco parameters.\n\n Unless you know what you are doing consider using\n the more friendly `tf.compat.v1.lite.toco_convert`.\n\n Args:\n model_flags_str: Serialized proto describing model properties, see\n `toco/model_flags.proto`.\n toco_flags_str: Serialized proto describing conversion properties, see\n `toco/toco_flags.proto`.\n input_data_str: Input data in serialized form (e.g. a graphdef is common)\n debug_info_str: Serialized `GraphDebugInfo` proto describing logging\n information. (default None)\n enable_mlir_converter: Enables MLIR-based conversion instead of the default\n TOCO conversion. (default False)\n Returns:\n Converted model in serialized form (e.g. a TFLITE model is common).\n Raises:\n ConverterError: When conversion fails in TFLiteConverter, usually due to\n ops not being supported.\n RuntimeError: When conversion fails, an exception is raised with the error\n message embedded.\n \"\"\"\n # TODO(aselle): When toco does not use fatal errors for failure, we can\n # switch this on.\n if not _toco_from_proto_bin:\n try:\n model_str = wrap_toco.wrapped_toco_convert(model_flags_str,\n toco_flags_str, input_data_str,\n debug_info_str,\n enable_mlir_converter)\n return model_str\n except Exception as e:\n raise ConverterError(str(e))\n\n # Windows and TemporaryFile are not that useful together,\n # since you cannot have two readers/writers. So we have to\n # make the temporaries and close and delete them explicitly.\n toco_filename, model_filename, input_filename, output_filename = (\n None, None, None, None)\n try:\n # Build all input files\n with _tempfile.NamedTemporaryFile(delete=False) as fp_toco, \\\n _tempfile.NamedTemporaryFile(delete=False) as fp_model, \\\n _tempfile.NamedTemporaryFile(delete=False) as fp_input, \\\n _tempfile.NamedTemporaryFile(delete=False) as fp_debug:\n toco_filename = fp_toco.name\n input_filename = fp_input.name\n model_filename = fp_model.name\n debug_filename = fp_debug.name\n\n fp_model.write(model_flags_str)\n fp_toco.write(toco_flags_str)\n fp_input.write(six.ensure_binary(input_data_str))\n debug_info_str = debug_info_str if debug_info_str else \"\"\n # if debug_info_str contains a \"string value\", then the call to\n # fp_debug.write(debug_info_str) will fail with the following error\n #\n # TypeError: a bytes-like object is required, not 'str'\n #\n # Some of the subtests within the \"convert_test\" unit-test fail\n # with the error shown above. So watch out for that scenario and\n # convert debug_info_str to bytes where needed\n if not isinstance(debug_info_str, bytes):\n fp_debug.write(debug_info_str.encode(\"utf-8\"))\n else:\n fp_debug.write(debug_info_str)\n\n # Reserve an output file\n with _tempfile.NamedTemporaryFile(delete=False) as fp:\n output_filename = fp.name\n\n # Run\n cmd = [\n _toco_from_proto_bin,\n model_filename,\n toco_filename,\n input_filename,\n output_filename,\n \"--debug_proto_file={}\".format(debug_filename),\n ]\n if enable_mlir_converter:\n cmd.append(\"--enable_mlir_converter\")\n cmdline = \" \".join(cmd)\n is_windows = _platform.system() == \"Windows\"\n proc = _subprocess.Popen(\n cmdline,\n shell=True,\n stdout=_subprocess.PIPE,\n stderr=_subprocess.STDOUT,\n close_fds=not is_windows)\n stdout, stderr = proc.communicate()\n exitcode = proc.returncode\n if exitcode == 0:\n with open(output_filename, \"rb\") as fp:\n return fp.read()\n else:\n stdout = _try_convert_to_unicode(stdout)\n stderr = _try_convert_to_unicode(stderr)\n raise ConverterError(\"See console for info.\\n%s\\n%s\\n\" % (stdout, stderr))\n finally:\n # Must manually cleanup files.\n for filename in [\n toco_filename, input_filename, model_filename, output_filename]:\n try:\n _os.unlink(filename)\n except (OSError, TypeError):\n pass\n\n\ndef build_toco_convert_protos(input_tensors,\n output_tensors,\n inference_type=lite_constants.FLOAT,\n inference_input_type=None,\n input_format=lite_constants.TENSORFLOW_GRAPHDEF,\n input_shapes=None,\n output_format=lite_constants.TFLITE,\n quantized_input_stats=None,\n default_ranges_stats=None,\n drop_control_dependency=True,\n reorder_across_fake_quant=False,\n allow_custom_ops=False,\n custom_opdefs=None,\n change_concat_input_ranges=False,\n post_training_quantize=False,\n quantize_to_float16=False,\n dump_graphviz_dir=None,\n dump_graphviz_video=False,\n target_ops=None,\n allow_nonexistent_arrays=False,\n debug_info=None,\n conversion_summary_dir=None):\n \"\"\"Builds protocol buffers describing a conversion of a model using TOCO.\n\n Typically this is to convert from TensorFlow GraphDef to TFLite, in which\n case the default `input_format` and `output_format` are sufficient.\n\n Args:\n input_tensors: List of input tensors. Type and shape are computed using\n `foo.shape` and `foo.dtype`.\n output_tensors: List of output tensors (only .name is used from this).\n inference_type: Target data type of real-number arrays in the output file.\n Must be `{tf.float32, tf.uint8}`. (default tf.float32)\n Must be `{tf.float32, tf.uint8}`. (default `inference_type`)\n inference_input_type: Target data type of real-number input arrays. Allows\n for a different type for input arrays in the case of quantization.\n input_format: Type of data to read Currently must be\n `{TENSORFLOW_GRAPHDEF}`. (default TENSORFLOW_GRAPHDEF)\n input_shapes: Input array shape. It needs to be a list of the same length\n as `input_tensors`, or None. (default None)\n output_format: Output file format. Currently must be `{TFLITE,\n GRAPHVIZ_DOT}`. (default TFLITE)\n quantized_input_stats: List of tuples of floats representing the mean and\n standard deviation. Each tuple maps to the corresponding input tensor.\n Only need if `inference_input_type` is `QUANTIZED_UINT8`.\n real_input_value = (quantized_input_value - mean_value) / std_dev_value.\n (default None)\n default_ranges_stats: Tuple of integers representing (min, max) range values\n for all arrays without a specified range. Intended for experimenting with\n quantization via \"dummy quantization\". (default None)\n drop_control_dependency: Boolean indicating whether to drop control\n dependencies silently. This is due to TFLite not supporting control\n dependencies. (default True)\n reorder_across_fake_quant: Boolean indicating whether to reorder FakeQuant\n nodes in unexpected locations. Used when the location of the FakeQuant\n nodes is preventing graph transformations necessary to convert the graph.\n Results in a graph that differs from the quantized training graph,\n potentially causing differing arithmetic behavior. (default False)\n allow_custom_ops: Boolean indicating whether to allow custom operations.\n When false any unknown operation is an error. When true, custom ops are\n created for any op that is unknown. The developer will need to provide\n these to the TensorFlow Lite runtime with a custom resolver.\n (default False)\n custom_opdefs: List of strings representing custom ops OpDefs that are\n included in the GraphDef. Required when using custom operations with the\n MLIR-based converter. (default None)\n change_concat_input_ranges: Boolean to change behavior of min/max ranges for\n inputs and outputs of the concat operator for quantized models. Changes\n the ranges of concat operator overlap when true. (default False)\n post_training_quantize: Boolean indicating whether to quantize the weights\n of the converted float model. Model size will be reduced and there will be\n latency improvements (at the cost of accuracy).\n (default False)\n quantize_to_float16: Boolean indicating whether to convert float buffers\n to float16. (default False)\n dump_graphviz_dir: Full filepath of folder to dump the graphs at various\n stages of processing GraphViz .dot files. Preferred over\n --output_format=GRAPHVIZ_DOT in order to keep the requirements of the\n output file. (default None)\n dump_graphviz_video: Boolean indicating whether to dump the graph after\n every graph transformation. (default False)\n target_ops: Experimental flag, subject to change. Set of OpsSet\n options indicating which converter to use.\n (default set([OpsSet.TFLITE_BUILTINS]))\n allow_nonexistent_arrays: Allow specifying array names that don't exist\n or are unused in the final graph. (default False)\n debug_info: `GraphDebugInfo` proto containing the stack traces for the\n original nodes referred by the converted graph.\n conversion_summary_dir: A string, the path to the generated conversion logs.\n\n Returns:\n model_flags, toco_flags, debug_info: three protocol buffers describing the\n conversion process and debug information.\n\n Raises:\n ValueError:\n If the input tensor type is unknown\n Missing mean_values or std_dev_values\n RuntimeError: If TOCO fails to convert (in which case the runtime error's\n error text will contain the TOCO error log)\n \"\"\"\n toco = _toco_flags_pb2.TocoFlags()\n toco.input_format = input_format\n toco.output_format = output_format\n toco.inference_type = util.convert_dtype_to_tflite_type(inference_type)\n if inference_input_type:\n toco.inference_input_type = util.convert_dtype_to_tflite_type(\n inference_input_type)\n else:\n toco.inference_input_type = toco.inference_type\n toco.drop_control_dependency = drop_control_dependency\n toco.reorder_across_fake_quant = reorder_across_fake_quant\n toco.allow_custom_ops = allow_custom_ops\n if custom_opdefs:\n toco.custom_opdefs.extend(custom_opdefs)\n toco.post_training_quantize = post_training_quantize\n toco.quantize_to_float16 = quantize_to_float16\n if default_ranges_stats:\n toco.default_ranges_min = default_ranges_stats[0]\n toco.default_ranges_max = default_ranges_stats[1]\n if dump_graphviz_dir:\n toco.dump_graphviz_dir = dump_graphviz_dir\n toco.dump_graphviz_include_video = dump_graphviz_video\n if conversion_summary_dir:\n toco.conversion_summary_dir = conversion_summary_dir\n if target_ops:\n if set(target_ops) == set([OpsSet.TFLITE_BUILTINS, OpsSet.SELECT_TF_OPS]):\n toco.enable_select_tf_ops = True\n elif set(target_ops) == set([OpsSet.SELECT_TF_OPS]):\n toco.enable_select_tf_ops = True\n toco.force_select_tf_ops = True\n\n model = _model_flags_pb2.ModelFlags()\n model.change_concat_input_ranges = change_concat_input_ranges\n for idx, input_tensor in enumerate(input_tensors):\n input_array = model.input_arrays.add()\n input_array.name = util.get_tensor_name(input_tensor)\n input_array.data_type = util.convert_dtype_to_tflite_type(\n input_tensor.dtype)\n\n if toco.inference_input_type in \\\n [_types_pb2.QUANTIZED_UINT8, _types_pb2.INT8]:\n if not quantized_input_stats:\n raise ValueError(\"std_dev and mean must be defined when \"\n \"inference_input_type is QUANTIZED_UINT8.\")\n input_array.mean_value, input_array.std_value = quantized_input_stats[idx]\n if input_shapes is None:\n shape = input_tensor.shape\n else:\n shape = input_shapes[idx]\n input_array.shape.dims.extend(list(map(int, shape)))\n\n for output_tensor in output_tensors:\n model.output_arrays.append(util.get_tensor_name(output_tensor))\n\n model.allow_nonexistent_arrays = allow_nonexistent_arrays\n\n return model, toco, debug_info\n\n\ndef toco_convert_graph_def(input_data, input_arrays_with_shape, output_arrays,\n enable_mlir_converter, *args, **kwargs):\n \"\"\"\"Convert a model using TOCO.\n\n This function is used to convert GraphDefs that cannot be loaded into\n TensorFlow to TFLite. Conversion can be customized by providing arguments\n that are forwarded to `build_toco_convert_protos` (see documentation for\n details).\n\n Args:\n input_data: Input data (i.e. often `sess.graph_def`),\n input_arrays_with_shape: Tuple of strings representing input tensor names\n and list of integers representing input shapes\n (e.g., [(\"foo\" : [1, 16, 16, 3])]). Use only when graph cannot be loaded\n into TensorFlow and when `input_tensors` is None. (default None)\n output_arrays: List of output tensors to freeze graph with. Use only when\n graph cannot be loaded into TensorFlow and when `output_tensors` is None.\n (default None)\n enable_mlir_converter: Enables MLIR-based conversion instead of TOCO\n conversion.\n *args: See `build_toco_convert_protos`,\n **kwargs: See `build_toco_convert_protos`.\n\n Returns:\n The converted data. For example if TFLite was the destination, then\n this will be a tflite flatbuffer in a bytes array.\n\n Raises:\n Defined in `build_toco_convert_protos`.\n \"\"\"\n model_flags, toco_flags, _ = build_toco_convert_protos(\n input_tensors=[], output_tensors=[], *args, **kwargs)\n\n for idx, (name, shape) in enumerate(input_arrays_with_shape):\n input_array = model_flags.input_arrays.add()\n if toco_flags.inference_input_type == _types_pb2.QUANTIZED_UINT8:\n if ((\"quantized_input_stats\" not in kwargs) or\n (not kwargs[\"quantized_input_stats\"])):\n raise ValueError(\"std_dev and mean must be defined when \"\n \"inference_input_type is QUANTIZED_UINT8.\")\n input_array.mean_value, input_array.std_value = kwargs[\n \"quantized_input_stats\"][idx]\n input_array.name = name\n input_array.shape.dims.extend(list(map(int, shape)))\n\n for name in output_arrays:\n model_flags.output_arrays.append(name)\n\n data = toco_convert_protos(\n model_flags.SerializeToString(),\n toco_flags.SerializeToString(),\n input_data.SerializeToString(),\n enable_mlir_converter=enable_mlir_converter)\n return data\n\n\ndef toco_convert_impl(input_data, input_tensors, output_tensors,\n enable_mlir_converter, *args, **kwargs):\n \"\"\"\"Convert a model using TOCO.\n\n Typically this function is used to convert from TensorFlow GraphDef to TFLite.\n Conversion can be customized by providing arguments that are forwarded to\n `build_toco_convert_protos` (see documentation for details).\n\n Args:\n input_data: Input data (i.e. often `sess.graph_def`),\n input_tensors: List of input tensors. Type and shape are computed using\n `foo.shape` and `foo.dtype`.\n output_tensors: List of output tensors (only .name is used from this).\n enable_mlir_converter: Enables MLIR-based conversion instead of TOCO\n conversion.\n *args: See `build_toco_convert_protos`,\n **kwargs: See `build_toco_convert_protos`.\n\n Returns:\n The converted data. For example if TFLite was the destination, then\n this will be a tflite flatbuffer in a bytes array.\n\n Raises:\n Defined in `build_toco_convert_protos`.\n \"\"\"\n model_flags, toco_flags, debug_info = build_toco_convert_protos(\n input_tensors, output_tensors, *args, **kwargs)\n debug_info_str = debug_info.SerializeToString() if debug_info else None\n data = toco_convert_protos(\n model_flags.SerializeToString(),\n toco_flags.SerializeToString(),\n input_data.SerializeToString(),\n debug_info_str=debug_info_str,\n enable_mlir_converter=enable_mlir_converter)\n return data\n\n\n@_tf_export(v1=[\"lite.toco_convert\"])\[email protected](None, \"Use `lite.TFLiteConverter` instead.\")\ndef toco_convert(input_data, input_tensors, output_tensors, *args, **kwargs):\n \"\"\"Convert a model using TOCO.\n\n Typically this function is used to convert from TensorFlow GraphDef to TFLite.\n Conversion can be customized by providing arguments that are forwarded to\n `build_toco_convert_protos` (see documentation for details). This function has\n been deprecated. Please use `lite.TFLiteConverter` instead.\n\n Args:\n input_data: Input data (i.e. often `sess.graph_def`),\n input_tensors: List of input tensors. Type and shape are computed using\n `foo.shape` and `foo.dtype`.\n output_tensors: List of output tensors (only .name is used from this).\n *args: See `build_toco_convert_protos`,\n **kwargs: See `build_toco_convert_protos`.\n\n Returns:\n The converted data. For example if TFLite was the destination, then\n this will be a tflite flatbuffer in a bytes array.\n\n Raises:\n Defined in `build_toco_convert_protos`.\n \"\"\"\n enable_mlir_converter = kwargs.get(\"enable_mlir_converter\", False)\n return toco_convert_impl(input_data, input_tensors, output_tensors,\n enable_mlir_converter, *args, **kwargs)\n"
] | [
[
"tensorflow.lite.python.util.get_tensor_name",
"tensorflow.lite.python.wrap_toco.wrapped_toco_convert",
"tensorflow.lite.python.util.convert_dtype_to_tflite_type",
"tensorflow.lite.toco.toco_flags_pb2.TocoFlags",
"tensorflow.python.util.deprecation.deprecated",
"tensorflow.lite.toco.model_flags_pb2.ModelFlags",
"tensorflow.python.util.tf_export.tf_export",
"tensorflow.python.platform.resource_loader.get_path_to_datafile"
]
] |
cverluise/parseEPO | [
"be1171a0f8e6fcafa711fa291aebb1fc2260d5e6"
] | [
"parseepo/serialize.py"
] | [
"import html2text\nimport pandas as pd\nfrom wasabi import Printer\n\nfrom parseepo import validate\nfrom parseepo.exception import SingleAttrException\nfrom parseepo.utils import prepare_name\n\nh = html2text.HTML2Text()\nmsg = Printer()\nNAMES = [\"EP\", \"Num\", \"Ext\", \"publication_date\", \"language\", \"attr\", \"text\"]\nNESTED_ATTR = [\"TITLE\", \"CLAIM\", \"AMEND\", \"title\", \"claims\", \"amendment\"]\n\n\ndef format_patent_df(\n data: list, prepare_names: bool = False, handle_html: bool = False\n):\n \"\"\"\n Return data as a prepared DataFrame from a list of rows\n Nb: Input is [publication_number[Row]].\n E.g. [['EP','0700059 A1','1996-03-06','de','TITLE',' Elektroma...'],\n ['EP','0700059 A1','1996-03-06','en','TITLE',' Electroma...'],\n ...\n :param data: List[List]\n :param prepare_names: bool, True if you want to prepare names for BQ compatibility\n :param handle_html: bool, True if you want to handle html\n :return: pd.DataFrame\n publication_date language attr text publication_number\n 0 1996-03-06 ... ... ... EP-0700059-A1\n 1 1996-03-06 ... ... ... EP-0700059-A1\n 2 1996-03-06 ... ... ... EP-0700059-A1\n 3 1996-03-06 ... ... ... EP-0700059-A1\n 4 1996-03-06 ... ... ... EP-0700059-A1\n 5 1996-03-06 ... ... ... EP-0700059-A1\n 6 1996-03-06 ... ... ... EP-0700059-A1\n \"\"\"\n\n df_ = pd.DataFrame(data, columns=NAMES)\n df_[\"publication_number\"] = df_[\"EP\"] + \"-\" + df_[\"Num\"] + \"-\" + df_[\"Ext\"]\n df_ = df_.drop([\"EP\", \"Num\", \"Ext\"], axis=1)\n\n if prepare_names:\n df_[\"attr\"] = df_[\"attr\"].apply(lambda x: prepare_name(x, True))\n if handle_html:\n df_[\"text\"] = df_[\"text\"].apply(lambda x: h.handle(x))\n return df_\n\n\ndef unnest_attr(patent_dict: dict, publication_number: str):\n \"\"\"\n Unnest flat attributes returned as nested by the batch aggregation operation in\n serialize_patent.\n Raises warning if expected flat attributes has multiple values.\n :param patent_dict: dict, returned by serialize_patent\n :param publication_number: str, e.g. 'EP-0600083-A1'\n :return: dict\n In:\n { ...,\n 'PDFEP': {'language': ['en'],\n 'text': ['https://data.epo.org/publication-server/...']},\n }\n Out:\n {...,\n 'PDFEP': 'https://data.epo.org/publication-server/...',}\n\n \"\"\"\n attrs = list(filter(lambda x: x not in NESTED_ATTR, patent_dict.keys()))\n for attr in attrs:\n val = patent_dict[attr][\"text\"]\n try:\n validate.single_attr(val, attr, publication_number)\n except SingleAttrException:\n msg.warn(\n f\"{publication_number}: {attr} has more than 1 value. Only the first value \"\n f\"was kept. Add {attr} to the list NESTED_ATTR to fix this behavior.\"\n )\n patent_dict.update(\n {\n attr: {\n \"text\": patent_dict[attr][\"text\"][0],\n \"language\": patent_dict[attr][\"language\"][0],\n }\n }\n )\n\n\ndef serialize_patent_df(patent_df: pd.DataFrame):\n \"\"\"\n Return the serialized patent\n :param patent_df: pd.DataFrame, returned by format_patent_df\n :return: dict\n {'ABSTR': '<p id=\"pa01\" num=\"0001\">A device ...',\n 'CLAIM': {'language': ['en'],\n 'text': ['<claim id=\"c-en-0001\" ...']},\n 'DESCR': '<heading id=\"h0001\">Field of ...',\n 'PDFEP': 'https://data.epo.org/publication-server/...',\n 'TITLE': {'language': ['de', 'en', 'fr'],\n 'text': ['VORRICHTUNG ZUM ...',\n 'DEVICE FOR CONVEYING ...',\n \"DISPOSITIF D'ACHEMINEMENT ...']},\n 'publication_date': '1994-06-08',\n 'publication_number': 'EP-0600083-A1'}\n \"\"\"\n publication_number = patent_df[\"publication_number\"].values[0]\n publication_date = patent_df[\"publication_date\"].values[0]\n\n out = (\n patent_df.drop([\"publication_number\", \"publication_date\"], axis=1)\n .groupby(\"attr\")\n .aggregate(list)\n .T.to_dict()\n )\n\n unnest_attr(out, publication_number)\n out.update({\"publication_number\": publication_number})\n out.update({\"publication_date\": publication_date})\n return out\n\n\ndef serialize_patent(\n data: list, prepare_names: bool = False, handle_html: bool = False\n):\n \"\"\"\n Return the serialized patent\n :param data: List[List[str]], E.g.\n [['EP','0700059 A1','1996-03-06','de','TITLE',' Elektroma...'],\n ['EP','0700059 A1','1996-03-06','en','TITLE',' Electroma...'],\n :param prepare_names: bool, True if you want to prepare names for BQ compatibility\n :param handle_html: bool, True if you want to handle html\n :return: dict\n \"\"\"\n out = format_patent_df(data, prepare_names, handle_html)\n out = serialize_patent_df(out)\n return out\n"
] | [
[
"pandas.DataFrame"
]
] |
luigiluz/pyampd | [
"cd247030f5a4ccd971da837b9b873cacbd7adfb3"
] | [
"pyampd/ampd.py"
] | [
"import numpy as np\nfrom scipy.ndimage import uniform_filter1d\nfrom scipy.signal import detrend\n\n\ndef find_peaks_original(x, scale=None, debug=False):\n \"\"\"Find peaks in quasi-periodic noisy signals using AMPD algorithm.\n\n Automatic Multi-Scale Peak Detection originally proposed in\n \"An Efficient Algorithm for Automatic Peak Detection in\n Noisy Periodic and Quasi-Periodic Signals\", Algorithms 2012, 5, 588-603\n https://doi.org/10.1109/ICRERA.2016.7884365\n\n Optimized implementation by Igor Gotlibovych, 2018\n\n\n Parameters\n ----------\n x : ndarray\n 1-D array on which to find peaks\n scale : int, optional\n specify maximum scale window size of (2 * scale + 1)\n debug : bool, optional\n if set to True, return the Local Scalogram Matrix, `LSM`,\n and scale with most local maxima, `l`,\n together with peak locations\n\n Returns\n -------\n pks: ndarray\n The ordered array of peak indices found in `x`\n\n \"\"\"\n x = detrend(x)\n N = len(x)\n L = N // 2\n if scale:\n L = min(scale, L)\n\n # create LSM matix\n LSM = np.zeros((L, N), dtype=bool)\n for k in np.arange(1, L):\n LSM[k - 1, k:N - k] = (\n (x[0:N - 2 * k] < x[k:N - k]) & (x[k:N - k] > x[2 * k:N])\n )\n\n # Find scale with most maxima\n G = LSM.sum(axis=1)\n l_scale = np.argmax(G)\n\n # find peaks that persist on all scales up to l\n pks_logical = np.min(LSM[0:l_scale, :], axis=0)\n pks = np.flatnonzero(pks_logical)\n if debug:\n return pks, LSM, l_scale\n return pks\n\n\ndef find_peaks(x, scale=None, debug=False):\n \"\"\"Find peaks in quasi-periodic noisy signals using AMPD algorithm.\n\n Extended implementation handles peaks near start/end of the signal.\n\n Optimized implementation by Igor Gotlibovych, 2018\n\n\n Parameters\n ----------\n x : ndarray\n 1-D array on which to find peaks\n scale : int, optional\n specify maximum scale window size of (2 * scale + 1)\n debug : bool, optional\n if set to True, return the Local Scalogram Matrix, `LSM`,\n weigted number of maxima, 'G',\n and scale at which G is maximized, `l`,\n together with peak locations\n\n Returns\n -------\n pks: ndarray\n The ordered array of peak indices found in `x`\n\n \"\"\"\n x = detrend(x)\n N = len(x)\n L = N // 2\n if scale:\n L = min(scale, L)\n\n # create LSM matix\n LSM = np.ones((L, N), dtype=bool)\n for k in np.arange(1, L + 1):\n LSM[k - 1, 0:N - k] &= (x[0:N - k] > x[k:N]\n ) # compare to right neighbours\n LSM[k - 1, k:N] &= (x[k:N] > x[0:N - k]) # compare to left neighbours\n\n # Find scale with most maxima\n G = LSM.sum(axis=1)\n G = G * np.arange(\n N // 2, N // 2 - L, -1\n ) # normalize to adjust for new edge regions\n l_scale = np.argmax(G)\n\n # find peaks that persist on all scales up to l\n pks_logical = np.min(LSM[0:l_scale, :], axis=0)\n pks = np.flatnonzero(pks_logical)\n if debug:\n return pks, LSM, G, l_scale\n return pks\n\n\ndef find_peaks_adaptive(x, window=None, debug=False):\n \"\"\"Find peaks in quasi-periodic noisy signals using ASS-AMPD algorithm.\n\n Adaptive Scale Selection Automatic Multi-Scale Peak Detection,\n an extension of AMPD -\n \"An Efficient Algorithm for Automatic Peak Detection in\n Noisy Periodic and Quasi-Periodic Signals\", Algorithms 2012, 5, 588-603\n https://doi.org/10.1109/ICRERA.2016.7884365\n\n Optimized implementation by Igor Gotlibovych, 2018\n\n\n Parameters\n ----------\n x : ndarray\n 1-D array on which to find peaks\n window : int, optional\n sliding window size for adaptive scale selection\n debug : bool, optional\n if set to True, return the Local Scalogram Matrix, `LSM`,\n and `adaptive_scale`,\n together with peak locations\n\n Returns\n -------\n pks: ndarray\n The ordered array of peak indices found in `x`\n\n \"\"\"\n x = detrend(x)\n N = len(x)\n if not window:\n window = N\n if window > N:\n window = N\n L = window // 2\n\n # create LSM matix\n LSM = np.ones((L, N), dtype=bool)\n for k in np.arange(1, L + 1):\n LSM[k - 1, 0:N - k] &= (x[0:N - k] > x[k:N]\n ) # compare to right neighbours\n LSM[k - 1, k:N] &= (x[k:N] > x[0:N - k]) # compare to left neighbours\n\n # Create continuos adaptive LSM\n ass_LSM = uniform_filter1d(LSM * window, window, axis=1, mode='nearest')\n normalization = np.arange(L, 0, -1) # scale normalization weight\n ass_LSM = ass_LSM * normalization.reshape(-1, 1)\n\n # Find adaptive scale at each point\n adaptive_scale = ass_LSM.argmax(axis=0)\n\n # construct reduced LSM\n LSM_reduced = LSM[:adaptive_scale.max(), :]\n mask = (np.indices(LSM_reduced.shape)[0] > adaptive_scale\n ) # these elements are outside scale of interest\n LSM_reduced[mask] = 1\n\n # find peaks that persist on all scales up to l\n pks_logical = np.min(LSM_reduced, axis=0)\n pks = np.flatnonzero(pks_logical)\n if debug:\n return pks, ass_LSM, adaptive_scale\n return pks\n"
] | [
[
"scipy.ndimage.uniform_filter1d",
"numpy.zeros",
"numpy.ones",
"numpy.min",
"scipy.signal.detrend",
"numpy.argmax",
"numpy.arange",
"numpy.indices",
"numpy.flatnonzero"
]
] |
bionlplab/heart_failure_mortality | [
"f3bbfe65fe6f2c2a076acb38697133b472bf2231"
] | [
"extract_features.py"
] | [
"import pandas as pd\nimport numpy as np\nfrom utils import *\nfrom sklearn.preprocessing import StandardScaler\nfrom collections import defaultdict\nimport re\n\ndef format_labels(file_path, timelines, mapping):\n\tmost_recent = mapping.sort_values([\"subject_id\", \"ordering_date\"], ascending=False).drop_duplicates(\"subject_id\", keep=\"first\")\n\n\tlabel_features = pd.read_csv(file_path)\n\tformatted_features = reformat4pycox([\"report_id\"], label_features)\n\n\t#Connect subject to report\n\tdata_frames = [timelines, most_recent]\n\tdata_df = reduce(lambda left,right: pd.merge(left,right,on=\"subject_id\"), data_frames)\n\n\t#Connect report to labels\n\tdata_frames = [data_df, formatted_features]\n\tdata_df = reduce(lambda left,right: pd.merge(left,right,on=\"report_id\"), data_frames)\n\n\tfor i in [\"ordering_date\", \"report_id\"]:\n\t del data_df[i]\n\n\treturn data_df\n\ndef format_hidden_features(file_path, timelines, mapping):\n\tloaded = np.load(file_path)\n\n\tmost_recent = mapping.sort_values([\"subject_id\", \"ordering_date\"], ascending=False).drop_duplicates(\"subject_id\", keep=\"first\")\n\treport_ids = list(most_recent['report_id'])\n\n\tmutable_file = {} \n\tfor id in report_ids:\n\t mutable_file[id] = loaded[id].flatten()\n\tloaded = mutable_file\n\n\tlabel_features = pd.DataFrame(loaded.values(), index=loaded)\n\n\tcols = list(label_features.columns)\n\txcols = [\"x\" + str(i) for i in cols]\n\trename_dict = dict(zip(cols,xcols))\n\trename_dict[\"index\"] = \"report_id\"\n\n\tlabel_features = label_features.reset_index().rename(columns=rename_dict)\n\n\t#Connect subject to report\n\tdata_frames = [timelines, most_recent]\n\tdata_df = reduce(lambda left,right: pd.merge(left,right,on=\"subject_id\"), data_frames)\n\n\t#Connect report to labels\n\tdata_frames = [data_df, label_features]\n\tdata_df = reduce(lambda left,right: pd.merge(left,right,on=\"report_id\"), data_frames)\n\n\tfor i in [\"ordering_date\", \"report_id\"]:\n\t del data_df[i]\n\n\treturn data_df\n\ndef format_hf_sequence(file_path, timelines, mapping):\n\tloaded = np.load(file_path)\n\t \n\ttop3_reports = mapping.sort_values([\"subject_id\", \"ordering_date\"], ascending=True).groupby(\"subject_id\").tail(3)\n\n\t#Create a list of report ids\n\treport_dict = top3_reports.groupby(\"subject_id\")[\"report_id\"].apply(list).to_dict()\n\n\t#Create a dict of report arrays. Format: key: array of report embeddings\n\tembedding_dict = defaultdict(list)\n\n\tfor k,v in report_dict.items():\n\t\tfor vi in v:\n\t\t embedding_dict[k].append(loaded[vi])\n\n\t\tembedding_dict[k] = np.vstack(embedding_dict[k])\n\n\t#Converting embedding dict into dataframe\n\tlabel_features = pd.DataFrame(embedding_dict.values(), index=embedding_dict)\n\n\tlabel_features[0] = label_features[0].apply(lambda x: add_paddings(x))\n\n\tlist2d = label_features[0]\n\n\tmerged = list(itertools.chain(*list2d))\n\n\tscaler = StandardScaler()\n\tscaler.fit(merged)\n\n\tlabel_features[0] = label_features[0].apply(lambda x: scaler.transform(x))\n\n\tcols = list(label_features.columns)\n\txcols = [\"x\" + str(i) for i in cols]\n\trename_dict = dict(zip(cols,xcols))\n\n\tlabel_features = label_features.rename(columns=rename_dict)\n\tlabel_features = label_features.reset_index().rename(columns={\"index\": \"subject_id\"})\n\n\tdata_frames = [timelines, label_features]\n\tdata_df = reduce(lambda left,right: pd.merge(left,right,on=\"subject_id\"), data_frames)\n\n\treturn data_df\n"
] | [
[
"pandas.merge",
"sklearn.preprocessing.StandardScaler",
"numpy.load",
"pandas.read_csv",
"numpy.vstack"
]
] |
derekmpham/mindmeld | [
"18189f956e4e3eb92df61fde95ec82f73b9efa91"
] | [
"mindmeld/converter/dialogflow.py"
] | [
"# -*- coding: utf-8 -*-\n#\n# Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.\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# http://www.apache.org/licenses/LICENSE-2.0\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\"\"\"This module contains the DialogflowConverter class used to convert Dialogflow projects\ninto Mindmeld projects\"\"\"\n\nimport json\nimport logging\nimport os\nimport re\n\nfrom sklearn.model_selection import train_test_split\n\nfrom mindmeld.converter.converter import Converter\n\nlogger = logging.getLogger(__name__)\n\n\nclass DialogflowConverter(Converter):\n \"\"\"The class is a sub class of the abstract Converter class. This class\n contains the methods required to convert a Dialogflow project into a MindMeld project\n \"\"\"\n\n sys_entity_map = {\n \"@sys.date-time\": \"sys_interval\",\n \"@sys.date\": \"sys_time\",\n \"@sys.date-period\": \"sys_interval\",\n \"@sys.time\": \"sys_time\",\n \"@sys.time-period\": \"sys_duration\",\n \"@sys.duration\": \"sys_duration\",\n \"@sys.number\": \"sys_number\",\n \"@sys.cardinal\": \"sys_number\",\n \"@sys.ordinal\": \"sys_ordinal\",\n \"@sys.unit-currency\": \"sys_amount-of-money\",\n \"@sys.unit-volume\": \"sys_volume\",\n \"@sys.email\": \"sys_email\",\n \"@sys.phone-number\": \"sys_phone-number\",\n \"@sys.url\": \"sys_url\",\n }\n\n # TODO: provide support for entities listed in sys_entity_map_todo\n sys_entity_map_todo = [\n \"@sys.number-integer\",\n \"@sys.number-sequence\",\n \"@sys.flight-number\",\n \"@sys.unit-area\",\n \"@sys.unit-length\",\n \"@sys.unit-speed\",\n \"@sys.unit-information\",\n \"@sys.percentage\",\n \"@sys.temperature\",\n \"@sys.duration\",\n \"@sys.age\",\n \"@sys.currency-name\",\n \"@sys.unit-area-name\",\n \"@sys.unit-length-name\",\n \"@sys.unit-speed-name\",\n \"@sys.unit-volume-name\",\n \"@sys.unit-weight-name\",\n \"@sys.unit-information-name\",\n \"@sys.address\",\n \"@sys.zip-code\",\n \"@sys.geo-capital\",\n \"@sys.geo-country\",\n \"@sys.geo-country-code\",\n \"@sys.geo-city\",\n \"@sys.geo-state\",\n \"@sys.geo-city\",\n \"@sys.geo-state\",\n \"@sys.place-attraction\",\n \"@sys.airport\",\n \"@sys.location\",\n \"@sys.given-name\",\n \"@sys.last-name\",\n \"@sys.person\",\n \"@sys.music-artist\",\n \"@sys.music-genre\",\n \"@sys.color\",\n \"@sys.language\",\n \"@sys.any\",\n ]\n\n def __init__(self, dialogflow_project_directory, mindmeld_project_directory):\n if os.path.exists(os.path.dirname(dialogflow_project_directory)):\n self.dialogflow_project_directory = dialogflow_project_directory\n self.mindmeld_project_directory = mindmeld_project_directory\n self.directory = os.path.dirname(os.path.realpath(__file__))\n self.entities_list = set()\n self.intents_list = set()\n else:\n msg = \"`{dialogflow_project_directory}` does not exist. Please verify.\"\n msg = msg.format(dialogflow_project_directory=dialogflow_project_directory)\n raise FileNotFoundError(msg)\n\n def create_mindmeld_directory(self):\n self.create_directory(self.mindmeld_project_directory)\n self.create_directory(os.path.join(self.mindmeld_project_directory, \"data\"))\n self.create_directory(os.path.join(self.mindmeld_project_directory, \"domains\"))\n self.create_directory(\n os.path.join(self.mindmeld_project_directory, \"domains\", \"general\")\n )\n self.create_directory(os.path.join(self.mindmeld_project_directory, \"entities\"))\n\n # =========================\n # create training data (entities, intents)\n # =========================\n\n def _create_entities_directories(self, entities):\n \"\"\" Creates directories + files for all languages/files.\n Currently does not use meta data in entityName.json files (the keys in var entities).\n \"\"\"\n for languages in entities.values():\n for sub in languages.values():\n dialogflow_entity_file = os.path.join(\n self.dialogflow_project_directory, \"entities\", sub + \".json\"\n )\n\n mindmeld_entity_directory_name = self.clean_check(\n sub, self.entities_list\n )\n\n mindmeld_entity_directory = os.path.join(\n self.mindmeld_project_directory,\n \"entities\",\n mindmeld_entity_directory_name,\n )\n\n self.create_directory(mindmeld_entity_directory)\n\n self._create_entity_file(\n dialogflow_entity_file, mindmeld_entity_directory\n )\n\n @staticmethod\n def _create_entity_file(dialogflow_entity_file, mindmeld_entity_directory):\n source_en = open(dialogflow_entity_file, \"r\")\n target_gazetteer = open(\n os.path.join(mindmeld_entity_directory, \"gazetteer.txt\"), \"w\"\n )\n target_mapping = open(\n os.path.join(mindmeld_entity_directory, \"mapping.json\"), \"w\"\n )\n\n datastore = json.load(source_en)\n mapping_dict = {\"entities\": []}\n\n for item in datastore:\n new_dict = {}\n while (\"value\" in item) and (item[\"value\"] in item[\"synonyms\"]):\n item[\"synonyms\"].remove(item[\"value\"])\n new_dict[\"whitelist\"] = item[\"synonyms\"]\n new_dict[\"cname\"] = item[\"value\"]\n mapping_dict[\"entities\"].append(new_dict)\n\n target_gazetteer.write(item[\"value\"] + \"\\n\")\n\n json.dump(mapping_dict, target_mapping, ensure_ascii=False, indent=2)\n\n source_en.close()\n target_gazetteer.close()\n target_mapping.close()\n\n def _create_intents_directories(self, intents):\n \"\"\" Creates directories + files for all languages/files.\"\"\"\n\n for languages in intents.values():\n for language, sub in languages.items():\n dialogflow_intent_file = os.path.join(\n self.dialogflow_project_directory, \"intents\", sub + \".json\"\n )\n\n mindmeld_intent_directory_name = self.clean_check(\n sub, self.intents_list\n )\n mindmeld_intent_directory = os.path.join(\n self.mindmeld_project_directory,\n \"domains\",\n \"general\",\n mindmeld_intent_directory_name,\n )\n\n self.create_directory(mindmeld_intent_directory)\n\n self._create_intent_file(\n dialogflow_intent_file, mindmeld_intent_directory, language\n )\n\n def _create_intent_file(\n self, dialogflow_intent_file, mindmeld_intent_directory, language\n ):\n source_en = open(dialogflow_intent_file, \"r\")\n target_test = open(os.path.join(mindmeld_intent_directory, \"test.txt\"), \"w\")\n target_train = open(os.path.join(mindmeld_intent_directory, \"train.txt\"), \"w\")\n\n datastore = json.load(source_en)\n all_text = []\n\n for usersay in datastore:\n sentence = \"\"\n for texts in usersay[\"data\"]:\n df_text = texts[\"text\"]\n if \"meta\" in texts and texts[\"meta\"] != \"@sys.ignore\":\n df_meta = texts[\"meta\"]\n\n if re.match(\n \"(@sys.).+\", df_meta\n ): # if text is a dialogflow sys entity\n if df_meta in DialogflowConverter.sys_entity_map:\n mm_meta = DialogflowConverter.sys_entity_map[df_meta]\n else:\n mm_meta = \"[DNE: {sysEntity}]\".format(sysEntity=df_meta[1:])\n logger.info(\n \"Unfortunately mindmeld does not currently support\"\n \"%s as a sys entity.\"\n \"Please create an entity for this.\",\n df_meta[1:],\n )\n\n entity_type = self.clean_name(mm_meta) + \"_entries_\" + language\n part = \"{\" + df_text + \"|\" + entity_type + \"}\"\n else:\n entity_type = (\n self.clean_name(df_meta[1:]) + \"_entries_\" + language\n )\n part = \"{\" + df_text + \"|\" + entity_type + \"}\"\n else:\n part = df_text\n\n sentence += part\n all_text.append(sentence)\n\n train, test = train_test_split(all_text, test_size=0.2)\n\n target_test.write(\"\\n\".join(test))\n target_train.write(\"\\n\".join(train))\n\n source_en.close()\n target_test.close()\n target_train.close()\n\n def _get_file_names(self, level):\n \"\"\" Gets the names of the entities from Dialogflow as a dictionary.\n levels (str): either \"entities\" or \"intents\"\n\n ex. if we had the following files in our entities directory:\n [\"test.json\", \"test_entries_en.json\", \"test_entries_de.json\"]\n it returns:\n {'test': {'en': 'test_entries_en', 'de': 'test_entries_de'}} \"\"\"\n\n directory = os.path.join(self.dialogflow_project_directory, level)\n files = os.listdir(directory)\n\n w = {\"entities\": \"entries\", \"intents\": \"usersays\"}\n p = r\".+(?<=(_\" + w[level] + \"_))(.*)(?=(.json))\"\n\n info = {}\n for name in files:\n match = re.match(p, name)\n\n if match:\n isbase = False\n base = name[: match.start(1)]\n language = match.group(2)\n else:\n isbase = True\n base = name[:-5]\n\n if base not in info:\n info[base] = {}\n\n if not isbase:\n info[base][language] = name[:-5]\n\n return info\n\n def create_mindmeld_training_data(self):\n entities = self._get_file_names(\"entities\")\n self._create_entities_directories(entities)\n\n intents = self._get_file_names(\"intents\")\n self._create_intents_directories(intents)\n\n # =========================\n # create init\n # =========================\n\n @staticmethod\n def create_handle(params):\n return \"@app.handle(\" + params + \")\"\n\n @staticmethod\n def create_header(function_name):\n return \"def \" + function_name + \"(request, responder):\"\n\n @staticmethod\n def create_function(handles, function_name, replies):\n assert isinstance(handles, list)\n\n result = \"\"\n for handle in handles:\n result += DialogflowConverter.create_handle(handle) + \"\\n\"\n result += DialogflowConverter.create_header(function_name) + \"\\n\"\n result += \" \" + \"replies = {}\".format(replies) + \"\\n\"\n result += \" \" + \"responder.reply(replies)\"\n return result\n\n @staticmethod\n def clean_name(name):\n \"\"\" Takes in a string and returns a valid folder name (no spaces, all lowercase).\"\"\"\n name = re.sub(r\"[^\\w\\s-]\", \"\", name).strip().lower()\n name = re.sub(r\"[-\\s]+\", \"_\", name)\n return name\n\n def clean_check(self, name, lst):\n \"\"\" Takes in a list of strings and a name.\n Returns name cleaned if the cleaned name is not found in lst.\"\"\"\n cleaned = self.clean_name(name)\n\n if cleaned not in lst:\n lst.add(cleaned)\n return cleaned\n else:\n logger.error(\n \"%s name has been created twice. Please ensure there \"\n \"are no duplicate names in the dialogflow files and \"\n \"filenames are valid (no spaces or special characters)\",\n cleaned,\n )\n\n def create_mindmeld_init(self):\n with open(\n os.path.join(self.mindmeld_project_directory, \"__init__.py\"), \"w\"\n ) as target:\n begin_info = [\n \"# -*- coding: utf-8 -*-\",\n '\"\"\"This module contains the MindMeld application\"\"\"',\n \"from mindmeld import Application\",\n \"app = Application(__name__)\",\n \"__all__ = ['app']\",\n ]\n\n for info, spacing in zip(begin_info, [1, 2, 1, 1, 0]):\n target.write(info + \"\\n\" * spacing)\n\n intents = self._get_file_names(\"intents\")\n\n for i, main in enumerate(intents.keys()):\n\n df_main = os.path.join(\n self.dialogflow_project_directory, \"intents\", main + \".json\"\n )\n\n with open(df_main) as source:\n if \"usersays\" in df_main:\n logger.error(\n \"Please check if your intent file\"\n \"names are correctly labeled.\"\n )\n\n datastore = json.load(source)\n replies = []\n\n for response in datastore[\"responses\"]:\n for message in response[\"messages\"]:\n language = message[\"lang\"]\n\n if \"speech\" in message:\n data = message[\"speech\"]\n\n replies = data if isinstance(data, list) else [data]\n\n if datastore[\"fallbackIntent\"]:\n function_name = \"default\" + \"_\" + language\n if language == \"en\":\n # TODO: support multiple defaults for languages\n handles = [\n \"default=True\",\n \"intent='unsupported'\",\n ]\n else:\n handles = [\"intent='unsupported'\"]\n else:\n function_name = \"renameMe\" + str(i) + \"_\" + language\n handles = [\n \"intent=\"\n + \"'\"\n + self.clean_name(datastore[\"name\"])\n + \"_usersays_\"\n + language\n + \"'\"\n ]\n\n target.write(\n \"\\n\\n\\n\"\n + self.create_function(\n handles=handles,\n function_name=function_name,\n replies=replies,\n )\n )\n target.write(\"\\n\")\n\n # =========================\n # convert project\n # =========================\n\n def convert_project(self):\n \"\"\" Converts a Dialogflow project into a MindMeld project.\n\n Dialogflow projects consist of entities and intents.\n note on languages:\n Dialogflow supports multiple languages and locales. They store their training\n data for different languages in different files. So, the name of each training\n file ends with a meta tag, two letters long for language, and an additional\n two letters for dialect (if applicable). For example, a file ending in \"_en-au\"\n indicates it's in English (Australia). Below we use \"la\" to represent this\n meta tag.\n\n entities folder contains:\n entityName.json - Meta data about entityName for all languages.\n entityName_entries_la.json - One for each language, contains entitiy mappings.\n\n intents folder contain:\n intentName.json - Contains rules, information about conversation flow, meta data.\n Contains previously mentioned information and responses for all languages.\n intentName_usersays_la.json - one for each language,\n contains training data to recognize intentName\n\n Limitations:\n - The converter is unable to create an entity when it encounters an\n unrecognized entity (an entity not defined under entities folder\n or system entities), and labels such entities as DNE in training data.\n - The converter currently does not automatically convert features like\n slot filling, contexts, and follow-up intents. Users can still implement such\n features and more.\n - Information in agent.json are not copied over.\n - There is no official support for different languages. Users can still\n implement this. The converter is able to successfully convert dialogflow\n bots that support multiple languages.\n\n Mindmeld:\n - Users can store data locally\n - Users can build a knowledge base (currently beta in Dialogflow).\n - Users can configure the machine learning models to best suit their needs.\n - Users have more flexibility in defining their own features, including\n ones like slot filling, contexts, and follow-up intents.\n \"\"\"\n\n logger.info(\"Converting project.\")\n\n # Create project directory with sub folders\n self.create_mindmeld_directory()\n\n # Transfer over test data from Dialogflow project and reformat to Mindmeld project\n self.create_mindmeld_training_data()\n file_loc = os.path.dirname(os.path.realpath(__file__))\n\n self.create_config(self.mindmeld_project_directory, file_loc)\n self.create_main(self.mindmeld_project_directory, file_loc)\n self.create_mindmeld_init()\n\n logger.info(\"Project converted.\")\n"
] | [
[
"sklearn.model_selection.train_test_split"
]
] |
offy284/Keras-GAN | [
"6652c626ba584ffd1c25ca4e925e6f131077395c"
] | [
"music_preprocessor/music_preprocessor.py"
] | [
"import itertools\nimport shutil\nimport os\nfrom os import listdir\nfrom os.path import isfile, join\nfrom tqdm import tqdm\nimport numpy as np\nimport scipy\nfrom scipy.io.wavfile import write, read\nfrom scipy.fftpack import fft\nfrom scipy import signal\nfrom scipy.fft import fftshift\nimport matplotlib.pyplot as plt\nfrom sklearn.preprocessing import MinMaxScaler\nimport matplotlib.pyplot as plt\n\nRESOLUTION_SCALE = 10\n\n\ndef flatten_dir(dir):\n print(\"Flattening MusicData directory...\")\n all_files = []\n dups = 0\n\n for root, _dirs, files in itertools.islice(os.walk(dir), 1, None):\n try:\n for filename in files:\n all_files.append(os.path.join(root, filename))\n except:\n dups += 1\n for filename in all_files:\n try:\n shutil.move(filename, dir)\n except:\n dups += 1\n\n print(f\"{dups} duplicate files removed\")\n\n\ndef generate_big_music(resolution_scale=RESOLUTION_SCALE):\n print(\"Generating big_music from MusicData directory...\")\n onlyfiles = [f for f in listdir(\"MusicData/\") if isfile(join(\"MusicData/\", f))]\n\n print(\"Normalizing big_music...\")\n square_size = 28 * resolution_scale\n big_music = np.empty((1)) # np.empty((len(onlyfiles), square_size, square_size, 1))\n\n for i in tqdm(range(len(onlyfiles))):\n file = onlyfiles[i]\n if \"-converted\" in file:\n x = scipy.io.wavfile.read(f\"MusicData/{file}\")\n x = x[1]\n\n #big_music = big_music.reshape(-1)\n\n '''\n print(f\"Building spectrogram...\")\n \n plt.specgram(x, Fs=44100)\n plt.savefig(f'MusicImageData/{file}.png')\n \n x = x.reshape(-1, 1)\n\n min_max_scaler = MinMaxScaler()\n x = (min_max_scaler.fit_transform(x) - .5) * 2\n\n samples = list(np.empty((int(x.shape[0] / square_size / square_size), square_size, square_size, 1)))\n rows = np.zeros((square_size, square_size, 1))\n cols = np.zeros((square_size, 1))\n\n for samplei in tqdm(range(len(samples))):\n for yi in range(square_size):\n for xi in range(square_size):\n cols[xi] = x[xi + yi * square_size + samplei * square_size * square_size]\n rows[yi] = cols\n samples[samplei] = rows\n '''\n\n print(\"Numpyifying x...\")\n big_music = np.concatenate([big_music, x])\n\n print(f\"big_music is of shape {big_music.shape}\")\n\n freqs, times, spectrogram = signal.spectrogram(big_music, 44100)\n spectrogram = spectrogram.reshape((spectrogram.shape[1], spectrogram.shape[0]))\n\n print(spectrogram.shape)\n\n filename = f\"spectrogram.npy\"\n print(f\"Saving {filename}...\")\n np.save(f\"{filename}\", spectrogram)\n\n filename = f\"freqs.npy\"\n print(f\"Saving {filename}...\")\n np.save(f\"{filename}\", freqs)\n\n filename = f\"times.npy\"\n print(f\"Saving {filename}...\")\n np.save(f\"{filename}\", times)\n\n\nif __name__ == '__main__':\n print(\"Music Preprocessor v0.1\")\n #flatten_dir()\n generate_big_music()"
] | [
[
"numpy.concatenate",
"scipy.signal.spectrogram",
"scipy.io.wavfile.read",
"numpy.empty",
"numpy.save"
]
] |
Didou09/tofu | [
"4a4e1f058bab8e7556ed9d518f90807cec605476"
] | [
"tofu/geom/_core_optics.py"
] | [
"\n\"\"\"\nThis module is the geometrical part of the ToFu general package\nIt includes all functions and object classes necessary for tomography on Tokamaks\n\"\"\"\n\n# Built-in\nimport sys\nimport os\nimport warnings\nimport copy\n\n\n# Common\nimport numpy as np\nimport scipy.interpolate as scpinterp\nimport scipy.stats as scpstats\nimport datetime as dtm\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\n\n# ToFu-specific\nfrom tofu import __version__ as __version__\nimport tofu.pathfile as tfpf\nimport tofu.utils as utils\nfrom . import _def as _def\nfrom . import _GG as _GG\nfrom . import _core\nfrom . import _check_optics\nfrom . import _comp_optics as _comp_optics\nfrom . import _plot_optics as _plot_optics\nimport tofu.spectro._rockingcurve as _rockingcurve\n\n\n__all__ = ['CrystalBragg']\n\n\n_Type = 'Tor'\n_NTHREADS = 16\n\n# rotate / translate instance\n_RETURN_COPY = False\n_USE_NON_PARALLELISM = True\n\n\n\"\"\"\n###############################################################################\n###############################################################################\n Ves class and functions\n###############################################################################\n###############################################################################\n\"\"\"\n\n\nclass CrystalBragg(utils.ToFuObject):\n \"\"\" A class defining crystals for Bragg diffraction\n\n A crystal can be of Type flat, cylindrical or spherical\n It is characterized by its:\n - geometry (Type, dimensions, curvature radii and position/orientation)\n - Material and lattice\n - Bragg parameters (angle vs lambda)\n\n\n Parameters\n ----------\n Id : str / tfpf.ID\n A name string or a pre-built tfpf.ID class to be used to identify this\n particular instance, if a string is provided, it is fed to tfpf.ID()\n dgeom : dict\n An array (2,N) or (N,2) defining the contour of the vacuum vessel in a\n cross-section, if not closed, will be closed automatically\n dspectral: str\n Flag indicating whether the vessel will be a torus ('Tor') or a linear\n device ('Lin')\n SavePath : None / str\n If provided, forces the default saving path of the object to the\n provided value\n\n \"\"\"\n\n # Fixed (class-wise) dictionary of default properties\n _ddef = {\n 'Id': {\n 'shot': 0, 'Exp': 'dummy', 'Diag': 'dummy',\n 'include': [\n 'Mod', 'Cls', 'Exp', 'Diag', 'Name', 'shot', 'version',\n ],\n },\n 'dgeom': {'Type': 'sph', 'Typeoutline': 'rect'},\n 'dmat': {},\n 'dbragg': {'braggref': np.pi/4.},\n 'dmisc': {'color': 'k'},\n }\n _dplot = {'cross':{'Elt':'P',\n 'dP':{'color':'k','lw':2},\n 'dI':{'color':'k','ls':'--','marker':'x','ms':8,'mew':2},\n 'dBs':{'color':'b','ls':'--','marker':'x','ms':8,'mew':2},\n 'dBv':{'color':'g','ls':'--','marker':'x','ms':8,'mew':2},\n 'dVect':{'color':'r','scale':10}},\n 'hor':{'Elt':'P',\n 'dP':{'color':'k','lw':2},\n 'dI':{'color':'k','ls':'--'},\n 'dBs':{'color':'b','ls':'--'},\n 'dBv':{'color':'g','ls':'--'},\n 'Nstep':50},\n '3d':{}}\n # _DEFLAMB = 3.971561e-10\n # _DEFNPEAKS = 12\n # _DREFLECT_DTYPES = {'specular':0, 'diffusive':1, 'ccube':2}\n\n\n # Does not exist beofre Python 3.6 !!!\n def __init_subclass__(cls, color='k', **kwdargs):\n # Python 2\n super(CrystalBragg,cls).__init_subclass__(**kwdargs)\n # Python 3\n #super().__init_subclass__(**kwdargs)\n cls._ddef = copy.deepcopy(CrystalBragg._ddef)\n cls._dplot = copy.deepcopy(CrystalBragg._dplot)\n cls._set_color_ddef(cls._color)\n\n @classmethod\n def _set_color_ddef(cls, color):\n cls._ddef['dmisc']['color'] = mpl.colors.to_rgba(color)\n\n def __init__(self, dgeom=None, dmat=None, dbragg=None,\n Id=None, Name=None, Exp=None, Diag=None, shot=None,\n fromdict=None, sep=None,\n SavePath=os.path.abspath('./'),\n SavePath_Include=tfpf.defInclude, color=None):\n\n # To replace __init_subclass__ for Python 2\n if sys.version[0]=='2':\n self._dstrip = utils.ToFuObjectBase._dstrip.copy()\n self.__class__._strip_init()\n\n # Create a dplot at instance level\n self._dplot = copy.deepcopy(self.__class__._dplot)\n\n kwdargs = locals()\n del kwdargs['self']\n # super()\n super(CrystalBragg,self).__init__(**kwdargs)\n\n def _reset(self):\n # super()\n super(CrystalBragg,self)._reset()\n self._dgeom = dict.fromkeys(self._get_keys_dgeom())\n self._dmat = dict.fromkeys(self._get_keys_dmat())\n self._dbragg = dict.fromkeys(self._get_keys_dbragg())\n self._dmisc = dict.fromkeys(self._get_keys_dmisc())\n #self._dplot = copy.deepcopy(self.__class__._ddef['dplot'])\n\n @classmethod\n def _checkformat_inputs_Id(cls, Id=None, Name=None,\n Exp=None, Diag=None, shot=None, Type=None,\n include=None,\n **kwdargs):\n if Id is not None:\n assert isinstance(Id,utils.ID)\n Name, Exp, Type = Id.Name, Id.Exp, Id.Type\n if Type is None:\n Type = cls._ddef['dgeom']['Type']\n if Exp is None:\n Exp = cls._ddef['Id']['Exp']\n if Diag is None:\n Diag = cls._ddef['Id']['Diag']\n if shot is None:\n shot = cls._ddef['Id']['shot']\n if include is None:\n include = cls._ddef['Id']['include']\n\n dins = {'Name':{'var':Name, 'cls':str},\n 'Exp': {'var':Exp, 'cls':str},\n 'Diag': {'var':Diag, 'cls':str},\n 'shot': {'var':shot, 'cls':int},\n 'Type': {'var':Type, 'in':['sph']},\n 'include':{'var':include, 'listof':str}}\n dins, err, msg = cls._check_InputsGeneric(dins)\n if err:\n raise Exception(msg)\n\n kwdargs.update({'Name':Name, 'shot':shot,\n 'Exp':Exp, 'Diag':Diag, 'Type':Type,\n 'include':include})\n return kwdargs\n\n ###########\n # Get largs\n ###########\n\n @staticmethod\n def _get_largs_dgeom(sino=True):\n largs = ['dgeom']\n return largs\n\n @staticmethod\n def _get_largs_dmat():\n largs = ['dmat']\n return largs\n\n @staticmethod\n def _get_largs_dbragg():\n largs = ['dbragg']\n return largs\n\n @staticmethod\n def _get_largs_dmisc():\n largs = ['color']\n return largs\n\n ###########\n # Get keys of dictionnaries\n ###########\n\n @staticmethod\n def _get_keys_dgeom():\n lk = ['Type', 'Typeoutline',\n 'summit', 'center', 'extenthalf', 'surface',\n 'nin', 'nout', 'e1', 'e2', 'rcurve',\n 'move', 'move_param', 'move_kwdargs']\n return lk\n\n @staticmethod\n def _get_keys_dmat():\n lk = ['formula', 'density', 'symmetry',\n 'lengths', 'angles', 'cut', 'd',\n 'alpha', 'beta', 'nin', 'nout', 'e1', 'e2']\n return lk\n\n @staticmethod\n def _get_keys_dbragg():\n lk = ['rockingcurve', 'lambref', 'braggref']\n return lk\n\n @staticmethod\n def _get_keys_dmisc():\n lk = ['color']\n return lk\n\n ###########\n # _init\n ###########\n\n def _init(self, dgeom=None, dmat=None, dbragg=None,\n color=None, **kwdargs):\n allkwds = dict(locals(), **kwdargs)\n largs = self._get_largs_dgeom()\n kwds = self._extract_kwdargs(allkwds, largs)\n self.set_dgeom(**kwds)\n largs = self._get_largs_dmat()\n kwds = self._extract_kwdargs(allkwds, largs)\n self.set_dmat(**kwds)\n largs = self._get_largs_dbragg()\n kwds = self._extract_kwdargs(allkwds, largs)\n self.set_dbragg(**kwds)\n largs = self._get_largs_dmisc()\n kwds = self._extract_kwdargs(allkwds, largs)\n self._set_dmisc(**kwds)\n self._dstrip['strip'] = 0\n\n ###########\n # set dictionaries\n ###########\n\n def set_dgeom(self, dgeom=None):\n self._dgeom = _check_optics._checkformat_dgeom(\n dgeom=dgeom, ddef=self._ddef['dgeom'],\n valid_keys=self._get_keys_dgeom(),\n )\n if self._dgeom['move'] is not None:\n self.set_move(\n move=self._dgeom['move'],\n param=self._dgeom['move_param'],\n **self._dgeom['move_kwdargs'],\n )\n\n def set_dmat(self, dmat=None):\n self._dmat = _check_optics._checkformat_dmat(\n dmat=dmat, dgeom=self._dgeom,\n ddef=self._ddef['dmat'],\n valid_keys=self._get_keys_dmat()\n )\n\n def set_dbragg(self, dbragg=None):\n self._dbragg = _check_optics._checkformat_dbragg(\n dbragg=dbragg,\n ddef=self._ddef['dbragg'],\n valid_keys=self._get_keys_dbragg(),\n dmat=self._dmat,\n )\n\n def _set_color(self, color=None):\n color = _check_optics._checkformat_inputs_dmisc(\n color=color, ddef=self._ddef,\n )\n self._dmisc['color'] = color\n self._dplot['cross']['dP']['color'] = color\n self._dplot['hor']['dP']['color'] = color\n # self._dplot['3d']['dP']['color'] = color\n\n def _set_dmisc(self, color=None):\n self._set_color(color)\n\n ###########\n # strip dictionaries\n ###########\n\n def _strip_dgeom(self, lkeep=None):\n lkeep = self._get_keys_dgeom()\n utils.ToFuObject._strip_dict(self._dgeom, lkeep=lkeep)\n\n def _strip_dmat(self, lkeep=None):\n lkeep = self._get_keys_dmat()\n utils.ToFuObject._strip_dict(self._dmat, lkeep=lkeep)\n\n def _strip_dbragg(self, lkeep=None):\n lkeep = self._get_keys_dbragg()\n utils.ToFuObject._strip_dict(self._dbragg, lkeep=lkeep)\n\n def _strip_dmisc(self, lkeep=['color']):\n utils.ToFuObject._strip_dict(self._dmisc, lkeep=lkeep)\n\n ###########\n # rebuild dictionaries\n ###########\n\n def _rebuild_dgeom(self, lkeep=None):\n lkeep = self._get_keys_dgeom()\n reset = utils.ToFuObject._test_Rebuild(self._dgeom, lkeep=lkeep)\n if reset:\n utils.ToFuObject._check_Fields4Rebuild(self._dgeom,\n lkeep=lkeep, dname='dgeom')\n self._set_dgeom(dgeom=self._dgeom)\n\n def _rebuild_dmat(self, lkeep=None):\n lkeep = self._get_keys_dmat()\n reset = utils.ToFuObject._test_Rebuild(self._dmat, lkeep=lkeep)\n if reset:\n utils.ToFuObject._check_Fields4Rebuild(self._dmat,\n lkeep=lkeep, dname='dmat')\n self.set_dmat(self._dmat)\n\n def _rebuild_dbragg(self, lkeep=None):\n lkeep = self._get_keys_dbragg()\n reset = utils.ToFuObject._test_Rebuild(self._dbragg, lkeep=lkeep)\n if reset:\n utils.ToFuObject._check_Fields4Rebuild(self._dbragg,\n lkeep=lkeep, dname='dbragg')\n self.set_dbragg(self._dbragg)\n\n def _rebuild_dmisc(self, lkeep=['color']):\n reset = utils.ToFuObject._test_Rebuild(self._dmisc, lkeep=lkeep)\n if reset:\n utils.ToFuObject._check_Fields4Rebuild(self._dmisc,\n lkeep=lkeep, dname='dmisc')\n self._set_dmisc(color=self.dmisc['color'])\n\n ###########\n # _strip and get/from dict\n ###########\n\n @classmethod\n def _strip_init(cls):\n cls._dstrip['allowed'] = [0,1]\n nMax = max(cls._dstrip['allowed'])\n doc = \"\"\"\n 1: Remove nothing\"\"\"\n doc = utils.ToFuObjectBase.strip.__doc__.format(doc,nMax)\n if sys.version[0]=='2':\n cls.strip.__func__.__doc__ = doc\n else:\n cls.strip.__doc__ = doc\n\n def strip(self, strip=0):\n # super()\n super(CrystalBragg, self).strip(strip=strip)\n\n def _strip(self, strip=0):\n if strip==0:\n self._rebuild_dgeom()\n self._rebuild_dmat()\n self._rebuild_dbragg()\n self._rebuild_dmisc()\n else:\n self._strip_dgeom()\n self._strip_dmat()\n self._strip_dbragg()\n self._strip_dmisc()\n\n def _to_dict(self):\n dout = {'dgeom':{'dict':self._dgeom, 'lexcept':None},\n 'dmat':{'dict':self._dmat, 'lexcept':None},\n 'dbragg':{'dict':self._dbragg, 'lexcept':None},\n 'dmisc':{'dict':self._dmisc, 'lexcept':None},\n 'dplot':{'dict':self._dplot, 'lexcept':None}}\n return dout\n\n def _from_dict(self, fd):\n self._dgeom.update(**fd.get('dgeom', {}))\n self._dmat.update(**fd.get('dmat', {}))\n self._dbragg.update(**fd.get('dbragg', {}))\n self._dmisc.update(**fd.get('dmisc', {}))\n self._dplot.update(**fd.get('dplot', {}))\n\n # -----------\n # Properties\n # -----------\n\n @property\n def Type(self):\n \"\"\"Return the type of structure \"\"\"\n return self._Id.Type\n\n @property\n def dgeom(self):\n return self._dgeom\n\n @property\n def dmat(self):\n \"\"\"Return the polygon defining the structure cross-section\"\"\"\n return self._dmat\n\n @property\n def dbragg(self):\n \"\"\"Return the polygon defining the structure cross-section\"\"\"\n return self._dbragg\n\n @property\n def dmisc(self):\n return self._dmisc\n\n # @property\n # def nin(self):\n # return self._dgeom['nin']\n\n # @property\n # def nout(self):\n # return self._dgeom['nout']\n\n # @property\n # def e1(self):\n # return self._dgeom['e1']\n\n # @property\n # def e2(self):\n # return self._dgeom['e2']\n\n @property\n def summit(self):\n return self._dgeom['summit']\n\n @property\n def center(self):\n return self._dgeom['center']\n\n @property\n def ismobile(self):\n return self._dgeom['move'] not in [None, False]\n\n @property\n def rockingcurve(self):\n if self._dbragg.get('rockingcurve') is not None:\n if self._dbragg['rockingcurve'].get('type') is not None:\n return self._dbragg['rockingcurve']\n raise Exception(\"rockingcurve was not set!\")\n\n # --------------------------------------\n # methods for getting unit vectors basis\n # --------------------------------------\n\n def get_unit_vectors(self, use_non_parallelism=None):\n \"\"\" Return the unit vectors (direct orthonormal basis)\n\n Depending on:\n use_non_parallelism: True => return the geometrical basis\n use_non_parallelism: False => return the mesh basis\n\n \"\"\"\n if use_non_parallelism is None:\n use_non_parallelism = _USE_NON_PARALLELISM\n\n if use_non_parallelism is True:\n nout = self._dmat['nout']\n e1 = self._dmat['e1']\n e2 = self._dmat['e2']\n else:\n nout = self._dgeom['nout']\n e1 = self._dgeom['e1']\n e2 = self._dgeom['e2']\n return nout, e1, e2, use_non_parallelism\n\n # -----------------\n # methods for color\n # -----------------\n\n def set_color(self, col):\n self._set_color(col)\n\n def get_color(self):\n return self._dmisc['color']\n\n # -----------------\n # methods for printing\n # -----------------\n\n def get_summary(self, sep=' ', line='-', just='l',\n table_sep=None, verb=True, return_=False):\n \"\"\" Summary description of the object content \"\"\"\n\n # -----------------------\n # Build material\n col0 = [\n 'formula', 'symmetry', 'cut', 'density',\n 'd (A)',\n 'bragg({:9.6} A) (deg)'.format(self._dbragg['lambref']*1e10),\n 'Type', 'outline', 'surface (cm²)', 'rcurve', 'rocking curve',\n ]\n ar0 = [self._dmat['formula'], self._dmat['symmetry'],\n str(self._dmat['cut']), str(self._dmat['density']),\n '{0:5.3f}'.format(self._dmat['d']*1.e10),\n str(self._dbragg['braggref']*180./np.pi),\n self._dgeom['Type'], self._dgeom['Typeoutline'],\n '{0:5.1f}'.format(self._dgeom['surface']*1.e4),\n '{0:6.3f}'.format(self._dgeom['rcurve'])]\n try:\n ar0.append(self.rockingcurve['type'])\n except Exception as err:\n ar0.append('None')\n\n\n # -----------------------\n # Build geometry\n col1 = ['half-extent', 'summit', 'center', 'nout', 'e1',\n 'alpha', 'beta']\n ar1 = [\n str(np.round(self._dgeom['extenthalf'], decimals=3)),\n str(np.round(self._dgeom['summit'], decimals=2)),\n str(np.round(self._dgeom['center'], decimals=2)),\n str(np.round(self._dmat['nout'], decimals=3)),\n str(np.round(self._dmat['e1'], decimals=3)),\n str(np.round(self._dmat['alpha'], decimals=6)),\n str(np.round(self._dmat['beta'], decimals=6)),\n ]\n if self._dgeom.get('move') not in [None, False]:\n col1 += ['move', 'param']\n ar1 += [self._dgeom['move'],\n str(np.round(self._dgeom['move_param'], decimals=5))]\n\n if self._dmisc.get('color') is not None:\n col1.append('color')\n ar1.append(str(self._dmisc['color']))\n\n lcol = [col0, col1]\n lar = [ar0, ar1]\n return self._get_summary(lar, lcol,\n sep=sep, line=line, table_sep=table_sep,\n verb=verb, return_=return_)\n # -----------------\n # methods for moving\n # -----------------\n\n def _update_or_copy(self, dgeom, pinhole=None,\n return_copy=None,\n name=None, diag=None, shot=None):\n if return_copy is None:\n return_copy = _RETURN_COPY\n for kk, vv in self._dgeom.items():\n if kk not in dgeom.keys():\n dgeom[kk] = vv\n if return_copy is True:\n if name is None:\n name = self.Id.Name + 'copy'\n if diag is None:\n diag = self.Id.Diag\n if shot is None:\n diag = self.Id.shot\n return self.__class__(dgeom=dgeom,\n dbragg=self._dbragg,\n dmat=self._dmat,\n color=self._dmisc['color'],\n Exp=self.Id.Exp,\n Diag=diag,\n Name=name,\n shot=shot,\n SavePath=self.Id.SavePath)\n else:\n dgeom0 = self.dgeom\n try:\n self.set_dgeom(dgeom=dgeom)\n self._dmat = _check_optics._checkformat_dmat(\n dmat={\n k0: v0 for k0, v0 in self._dmat.items()\n if k0 not in ['nin', 'nout', 'e1', 'e2']\n },\n dgeom=self._dgeom,\n ddef=self._ddef['dmat'],\n valid_keys=self._get_keys_dmat()\n )\n except Exception as err:\n # Make sure instance does not move\n self.set_dgeom(dgeom=dgeom0)\n msg = (str(err)\n + \"\\nAn exception occured during updating\\n\"\n + \" => instance unmoved\")\n raise Exception(msg)\n\n def _rotate_or_translate(self, func, **kwdargs):\n pts = np.array([self._dgeom['summit'], self._dgeom['center']]).T\n if 'rotate' in func.__name__:\n vect = np.array([\n self._dgeom['nout'],\n self._dgeom['e1'],\n self._dgeom['e2']\n ]).T\n pts, vect = func(pts=pts, vect=vect, **kwdargs)\n return {'summit': pts[:, 0], 'center': pts[:, 1],\n 'nout': vect[:, 0], 'nin': -vect[:, 0],\n 'e1': vect[:, 1], 'e2': vect[:, 2]}\n else:\n pts = func(pts=pts, **kwdargs)\n return {'summit': pts[:, 0], 'center': pts[:, 1]}\n\n def translate_in_cross_section(self, distance=None, direction_rz=None,\n phi=None,\n return_copy=None,\n diag=None, name=None, shot=None):\n \"\"\" Translate the instance in the cross-section \"\"\"\n if phi is None:\n phi = np.arctan2(*self.summit[1::-1])\n msg = (\"Poloidal plane was not explicitely specified\\n\"\n + \" => phi set to self.summit's phi ({})\".format(phi))\n warnings.warn(msg)\n dgeom = self._rotate_or_translate(\n self._translate_pts_poloidal_plane,\n phi=phi, direction_rz=direction_rz, distance=distance)\n return self._update_or_copy(dgeom,\n return_copy=return_copy,\n diag=diag, name=name, shot=shot)\n\n def translate_3d(self, distance=None, direction=None,\n return_copy=None,\n diag=None, name=None, shot=None):\n \"\"\" Translate the instance in provided direction \"\"\"\n dgeom = self._rotate_or_translate(\n self._translate_pts_3d,\n direction=direction, distance=distance)\n return self._update_or_copy(dgeom,\n return_copy=return_copy,\n diag=diag, name=name, shot=shot)\n\n def rotate_in_cross_section(self, angle=None, axis_rz=None,\n phi=None,\n return_copy=None,\n diag=None, name=None, shot=None):\n \"\"\" Rotate the instance in the cross-section \"\"\"\n if phi is None:\n phi = np.arctan2(*self.summit[1::-1])\n msg = (\"Poloidal plane was not explicitely specified\\n\"\n + \" => phi set to self.summit's phi ({})\".format(phi))\n warnings.warn(msg)\n dgeom = self._rotate_or_translate(\n self._rotate_pts_vectors_in_poloidal_plane,\n axis_rz=axis_rz, angle=angle, phi=phi)\n return self._update_or_copy(dgeom,\n return_copy=return_copy,\n diag=diag, name=name, shot=shot)\n\n def rotate_around_torusaxis(self, angle=None,\n return_copy=None,\n diag=None, name=None, shot=None):\n \"\"\" Rotate the instance around the torus axis \"\"\"\n dgeom = self._rotate_or_translate(\n self._rotate_pts_vectors_around_torusaxis,\n angle=angle)\n return self._update_or_copy(dgeom,\n return_copy=return_copy,\n diag=diag, name=name, shot=shot)\n\n def rotate_around_3daxis(self, angle=None, axis=None,\n return_copy=None,\n diag=None, name=None, shot=None):\n \"\"\" Rotate the instance around the provided 3d axis \"\"\"\n dgeom = self._rotate_or_translate(\n self._rotate_pts_vectors_around_3daxis,\n axis=axis, angle=angle)\n return self._update_or_copy(dgeom,\n return_copy=return_copy,\n diag=diag, name=name, shot=shot)\n\n def set_move(self, move=None, param=None, **kwdargs):\n \"\"\" Set the default movement parameters\n\n A default movement can be set for the instance, it can be any of the\n pre-implemented movement (rotations or translations)\n This default movement is the one that will be called when using\n self.move()\n\n Specify the type of movement via the name of the method (passed as a\n str to move)\n\n Specify, for the geometry of the instance at the time of defining this\n default movement, the current value of the associated movement\n parameter (angle / distance). This is used to set an arbitrary\n difference for user who want to use absolute position values\n The desired incremental movement to be performed when calling self.move\n will be deduced by substracting the stored param value to the provided\n param value. Just set the current param value to 0 if you don't care\n about a custom absolute reference.\n\n kwdargs must be a parameters relevant to the chosen method (axis,\n direction...)\n\n e.g.:\n self.set_move(move='rotate_around_3daxis',\n param=0.,\n axis=([0.,0.,0.], [1.,0.,0.]))\n self.set_move(move='translate_3d',\n param=0.,\n direction=[0.,1.,0.])\n \"\"\"\n move, param, kwdargs = self._checkformat_set_move(move, param, kwdargs)\n self._dgeom['move'] = move\n self._dgeom['move_param'] = param\n if isinstance(kwdargs, dict) and len(kwdargs) == 0:\n kwdargs = None\n self._dgeom['move_kwdargs'] = kwdargs\n\n def move(self, param):\n \"\"\" Set new position to desired param according to default movement\n\n Can only be used if default movement was set before\n See self.set_move()\n \"\"\"\n param = self._move(param, dictname='_dgeom')\n self._dgeom['move_param'] = param\n\n # -----------------\n # methods for rocking curve\n # -----------------\n\n def get_rockingcurve_func(self, lamb=None, n=None):\n \"\"\" Return the rocking curve function\n\n Also return the wavelength (lamb) (in meters) for which it was computed\n and the associated reference bragg angle (in rad)\n\n \"\"\"\n drock = self.rockingcurve\n if drock['type'] == 'tabulated-1d':\n if lamb is not None and lamb != drock['lamb']:\n msg = (\"rocking curve was tabulated only for:\\n\"\n + \"\\tlamb = {} m\\n\".format(lamb)\n + \" => Please let lamb=None\")\n raise Exception(msg)\n lamb = drock['lamb']\n bragg = self._checkformat_bragglamb(lamb=lamb, n=n)\n func = scpinterp.interp1d(drock['dangle'] + bragg, drock['value'],\n kind='linear', bounds_error=False,\n fill_value=0, assume_sorted=True)\n\n elif drock['type'] == 'tabulated-2d':\n lmin, lmax = drock['lamb'].min(), drock['lamb'].max()\n if lamb is None:\n lamb = drock['lamb']\n if lamb < lmin or lamb > lmax:\n msg = (\"rocking curve was tabulated only in interval:\\n\"\n + \"\\tlamb in [{}; {}] m\\n\".format(lmin, lmax)\n + \" => Please set lamb accordingly\")\n raise Exception(msg)\n bragg = self._checkformat_bragglamb(lamb=lamb, n=n)\n\n def func(angle, lamb=lamb, bragg=bragg, drock=drock):\n return scpinterp.interp2d(drock['dangle']+bragg, drock['lamb'],\n drock['value'], kind='linear',\n bounds_error=False, fill_value=0,\n assume_sorted=True)(angle, lamb)\n\n else:\n # TBC\n raise NotImplementedError\n def func(angle, d=d, delta_bragg=delta_bragg,\n Rmax=drock['Rmax'], sigma=drock['sigma']):\n core = sigma**2/((angle - (bragg+delta_bragg))**2 + sigma**2)\n if Rmax is None:\n return core/(sigma*np.pi)\n else:\n return Rmax*core\n return func, lamb, bragg\n\n def plot_rockingcurve(self, lamb=None, n=None, sigma=None,\n npts=None, color=None, ang_units=None,\n dmargin=None, fs=None, ax=None, legend=None):\n drock = self.rockingcurve\n func, lamb, bragg = self.get_rockingcurve_func(lamb=lamb, n=n)\n axtit = 'Rocking curve for ' + self.Id.Name\n return _plot_optics.CrystalBragg_plot_rockingcurve(\n func=func, bragg=bragg, lamb=lamb,\n sigma=sigma, npts=npts,\n ang_units=ang_units, axtit=axtit, color=color,\n fs=fs, ax=ax, legend=legend)\n\n def compute_rockingcurve(\n self, ih=None, ik=None, il=None, lamb=None,\n use_non_parallelism=None, na=None,\n alpha_limits=None,\n therm_exp=None, plot_therm_exp=None,\n plot_asf=None, plot_power_ratio=None,\n plot_asymmetry=None, plot_cmaps=None,\n verb=None, returnas=None,\n ):\n return _rockingcurve.compute_rockingcurve(\n ih=ih, ik=ik, il=il, lamb=lamb,\n use_non_parallelism=use_non_parallelism, na=na,\n alpha_limits=alpha_limits,\n therm_exp=therm_exp, plot_therm_exp=plot_therm_exp,\n plot_asf=plot_asf, plot_power_ratio=plot_power_ratio,\n plot_asymmetry=plot_asymmetry, plot_cmaps=plot_cmaps,\n verb=None, returnas=None,\n )\n\n def plot_var_temp_changes_wavelengths(\n self, ih=None, ik=None, il=None, lambdas=None,\n use_non_parallelism=None, na=None,\n alpha_limits=None,\n therm_exp=None, plot_therm_exp=None,\n plot_asf=None, plot_power_ratio=None,\n plot_asymmetry=None, plot_cmaps=None,\n quantity=None,\n curv_radius=None, pixel_size=None,\n ):\n return _rockingcurve.plot_var_temp_changes_wavelengths(\n ih=ih, ik=ik, il=il, lambdas=lambdas,\n use_non_parallelism=use_non_parallelism, na=na,\n alpha_limits=alpha_limits,\n therm_exp=therm_exp, plot_therm_exp=plot_therm_exp,\n plot_asf=plot_asf, plot_power_ratio=plot_power_ratio,\n plot_asymmetry=plot_asymmetry, plot_cmaps=plot_cmaps,\n quantity=quantity,\n curv_radius=curv_radius, pixel_size=pixel_size,\n )\n\n # -----------------\n # methods for surface and contour sampling\n # -----------------\n\n def sample_outline_plot(self, use_non_parallelism=None, res=None):\n if self._dgeom['Type'] == 'sph':\n if self._dgeom['Typeoutline'] == 'rect':\n nout, e1, e2, use_non_parallelism = self.get_unit_vectors(\n use_non_parallelism=use_non_parallelism,\n )\n outline = _comp_optics.CrystBragg_sample_outline_plot_sphrect(\n self._dgeom['summit'] - nout*self._dgeom['rcurve'],\n nout,\n e1,\n e2,\n self._dgeom['rcurve'],\n self._dgeom['extenthalf'],\n res,\n )\n else:\n raise NotImplementedError\n else:\n raise NotImplementedError\n return outline\n\n # -----------------\n # methods for surface and contour sampling\n # -----------------\n\n def _checkformat_bragglamb(self, bragg=None, lamb=None, n=None):\n lc = [lamb is not None, bragg is not None]\n if not any(lc):\n lamb = self._dbragg['lambref']\n lc[0] = True\n assert np.sum(lc) == 1, \"Provide lamb xor bragg!\"\n if lc[0]:\n bragg = self.get_bragg_from_lamb(\n np.atleast_1d(lamb), n=n,\n )\n else:\n bragg = np.atleast_1d(bragg)\n return bragg\n\n def _checkformat_get_Rays_from(self, phi=None, bragg=None):\n assert phi is not None\n assert bragg is not None\n bragg = np.atleast_1d(bragg)\n phi = np.atleast_1d(phi)\n nrays = max(phi.size, bragg.size)\n if not phi.shape == bragg.shape:\n if phi.size == 1:\n phi = np.full(bragg.shape, phi[0])\n elif bragg.size == 1:\n bragg = np.full(phi.shape, bragg[0])\n else:\n msg = \"phi and bragg/lamb must have the same shape!\\n\"\n msg += \" phi.shape: %s\\n\"%str(phi.shape)\n msg += \" bragg/lamb.shape: %s\\n\"%str(bragg.shape)\n raise Exception(msg)\n return phi, bragg\n\n def _get_rays_from_cryst(\n self,\n phi=None, bragg=None,\n lamb=None, n=None,\n dtheta=None, psi=None,\n ntheta=None, npsi=None,\n use_non_parallelism=None,\n include_summit=None,\n grid=None,\n ):\n\n # Get phi, bragg\n bragg = self._checkformat_bragglamb(bragg=bragg, lamb=lamb)\n phi, bragg = self._checkformat_get_Rays_from(phi=phi, bragg=bragg)\n # assert phi.ndim == 1\n\n # Get local summits, nout, e1, e2\n pts_start, nout, e1, e2 = self.get_local_noute1e2(\n dtheta=dtheta, psi=psi,\n use_non_parallelism=use_non_parallelism,\n ntheta=ntheta, npsi=npsi,\n include_summit=include_summit,\n )\n nin = -nout\n # reshape for broadcast\n if grid is True:\n nin = nin[..., None]\n e1 = e1[..., None]\n e2 = e2[..., None]\n else:\n assert bragg.shape == nin.shape[1:]\n\n # Compute start point (D) and unit vectors (us)\n vect = (\n np.sin(bragg)*nin\n + np.cos(bragg)*(np.cos(phi)*e1 + np.sin(phi)*e2)\n )\n return pts_start, vect\n\n def get_rays_from_cryst(\n self,\n phi=None, bragg=None,\n lamb=None, n=None,\n dtheta=None, psi=None,\n use_non_parallelism=None,\n ntheta=None, npsi=None,\n include_summit=None,\n det=None, config=None, length=None,\n returnas=None,\n return_xixj=None,\n grid=None,\n ):\n \"\"\" Return rays stemming from the crystal\n\n The rays are defined by a start point (on the crystal surface) and\n either an end point or a unit vector\n\n Start points\n ------------\n The start point is the crystal summit by default\n But that can be changed using:\n - ('dtheta', 'psi'): can be arbitrary but with same shape\n up to 4 dimensions\n - ('ntheta', 'npsi', 'include_summit'): will be used to\n compute the envelop (contour) of the crystal, as 2 1d arrays\n\n These arguments are fed to self.get_local_noute1e2() which will compute\n the start points and return them as shape (3, psi.shape)\n\n End point or unit vector\n ------------------------\n End point are computed automatically if:\n - 'config' is provided: ray-tracing is done like for any camera\n - 'det' is provided: xi and xj can be computed\n\n Returning format\n ----------------\n\n The rays can be returned as:\n - '(pts, vect, length)': a tuple of:\n - pts: array of start points on the crystal\n (only the summit by default)\n - vect: array\n - length:\n - '(pts, vect)': a tuple with only pts and vect\n - 'pts': a tuple, where both start and end points are returned\n All arrays represent (X, Y, Z) cartesian coordinates in the tokamak's\n frame\n\n Optionally, can return the (xi, xj) coordinates of points if a detector\n (det) is provided.\n\n \"\"\"\n\n # -----------\n # Check input\n if returnas is None:\n returnas = 'pts'\n if return_xixj is None:\n return_xixj = False\n\n lret = ['(pts, vect, length)', '(pts, vect)', 'pts'] # , object]\n if returnas not in lret:\n msg = (\n \"Arg returnas must be in:\\n\"\n + \"\\t- '(pts, vect, length)': starting points, unit vector,\"\n + \" length\\n\"\n + \"\\t- 'pts': starting and ending points\\n\"\n # + \"\\t- object: CamLOS1D instance\\n\"\n )\n raise Exception(msg)\n\n det = self._checkformat_det(det)\n if length is None:\n length = 10.\n\n if grid is None:\n try:\n grid = bragg.shape != dtheta.shape\n except Exception as err:\n grid = True\n\n # -----------\n # Get starting point and vectors\n pts_start, vect = self._get_rays_from_cryst(\n phi=phi, bragg=bragg,\n lamb=lamb, n=n,\n dtheta=dtheta, psi=psi,\n use_non_parallelism=use_non_parallelism,\n ntheta=ntheta, npsi=npsi,\n include_summit=include_summit,\n grid=grid,\n )\n\n if returnas == '(pts, vect)':\n return pts_start, vect\n\n # -----------\n # Get length (minimum between conf, det, length)\n vshape = vect.shape\n dk = {\n k0: np.full(vshape[1:], np.nan)\n for k0 in ['config', 'det', 'length']\n }\n xi, xj = None, None\n if config is not None:\n # Here insert ray-tracing from config!\n if vshape != pts_start.shape:\n if len(vshape) == 3 and len(pts_start.shape) == 2:\n D = np.reshape(\n np.repeat(pts_start[..., None], vshape[-1], axis=-1),\n (3, -1),\n )\n u = vect.reshape((3, -1))\n else:\n msg = (\n \"Not treated case!\\n\"\n f\"\\t- pts_start.shape: {pts_start.shape}\\n\"\n f\"\\t- vect.shape: {vshape}\\n\"\n )\n raise Exception(msg)\n else:\n if len(vshape) > 2:\n D = pts_start.reshape((3, -1))\n u = vect.reshape((3, -1))\n else:\n D = pts_start\n u = vect\n\n rays = _core.Rays(\n dgeom=(D, u),\n config=config,\n strict=False,\n Name='dummy',\n Diag='dummy',\n Exp='dummy',\n )\n if u.shape != vshape:\n kout = rays.dgeom['kOut'].reshape(vshape[1:])\n else:\n kout = rays.dgeom['kOut']\n dk['config'] = kout\n\n if det is not None and det is not False:\n shape = tuple([3] + [1 for ii in range(vect.ndim-1)])\n cent = det['cent'].reshape(shape)\n nout = det['nout'].reshape(shape)\n if grid is True:\n k = (\n np.sum((cent-pts_start[..., None])*nout, axis=0)\n / np.sum(vect*nout, axis=0)\n )\n else:\n k = (\n np.sum((cent-pts_start)*nout, axis=0)\n / np.sum(vect*nout, axis=0)\n )\n dk['det'][k >= 0.] = k[k >= 0.]\n if return_xixj is True:\n if grid:\n pts_end = pts_start[..., None] + dk['det'][None, ...]*vect\n else:\n pts_end = pts_start + dk['det'][None, ...]*vect\n ei = det['ei'].reshape(shape)\n ej = det['ej'].reshape(shape)\n xi = np.sum((pts_end - cent)*ei, axis=0)\n xj = np.sum((pts_end - cent)*ej, axis=0)\n\n if length is not None:\n dk['length'][:] = length\n\n k = np.nanmin([vv for vv in dk.values() if vv is not None], axis=0)\n\n # -----------\n # return\n if returnas == 'pts':\n if grid:\n pts_end = pts_start[..., None] + k[None, ...]*vect\n if return_xixj:\n return pts_start, pts_end, xi, xj\n else:\n return pts_start, pts_end\n else:\n pts_end = pts_start + k[None, ...]*vect\n if return_xixj:\n return pts_start, pts_end, xi, xj\n else:\n return pts_start, pts_end\n elif returnas == '(pts, vect, length)':\n if return_xixj:\n return pts_start, vect, k, xi, xj\n else:\n return pts_start, vect, k\n\n # -----------------\n # methods for crystal splitting\n # -----------------\n\n def split(self, direction=None, nb=None):\n\n # ------------\n # check inputs\n if direction is None:\n direction = 'e1'\n if direction not in ['e1', 'e2']:\n msg = (\n \"Arg direction must be either:\\n\"\n \"\\t- 'e1': split along vector 'e1' (~horizontally)\\n\"\n \"\\t- 'e2': split along vector 'e2' (~vertically)\\n\"\n f\"You provided: {direction}\"\n )\n raise Exception(msg)\n\n if nb is None:\n nb = 2\n if not (isinstance(nb, int) and nb > 1):\n msg = (\n \"Arg nb must be a int > 1 !\\n\"\n \"It specifies the number of equal parts desired\\n\"\n f\"You provided: {nb}\"\n )\n raise Exception(msg)\n\n # ---------------\n # split\n\n edges = np.linspace(-1, 1, nb+1)\n mid = 0.5*(edges[1:] + edges[:-1])[None, :]\n if direction == 'e2':\n dtheta = mid*self._dgeom['extenthalf'][1]\n psi = np.zeros((1, nb), dtype=float)\n extenthalf = [\n self._dgeom['extenthalf'][0],\n self._dgeom['extenthalf'][1]/nb,\n ]\n else:\n dtheta = np.zeros((1, nb), dtype=float)\n psi = mid*self._dgeom['extenthalf'][0]\n extenthalf = [\n self._dgeom['extenthalf'][0]/nb,\n self._dgeom['extenthalf'][1],\n ]\n\n nouts = (\n np.cos(dtheta)*(\n self._dgeom['nout'][:, None]*np.cos(psi)\n + self._dgeom['e1'][:, None]*np.sin(psi)\n )\n + np.sin(dtheta)*self._dgeom['e2'][:, None]\n )\n e1s = (\n -self._dgeom['nout'][:, None]*np.sin(psi)\n + self._dgeom['e1'][:, None]*np.cos(psi)\n )\n e2s = np.array([\n nouts[1, :]*e1s[2, :] - nouts[2, :]*e1s[1, :],\n nouts[2, :]*e1s[0, :] - nouts[0, :]*e1s[2, :],\n nouts[0, :]*e1s[1, :] - nouts[1, :]*e1s[0, :],\n\n ])\n\n # -----------\n # Construct list of instances\n\n lobj = [\n self.__class__(\n dgeom={\n 'rcurve': self._dgeom['rcurve'],\n 'center': self._dgeom['center'],\n 'nout': nouts[:, ii],\n 'e1': e1s[:, ii],\n 'e2': e2s[:, ii],\n 'extenthalf': extenthalf,\n },\n dmat={\n k0: v0 for k0, v0 in self._dmat.items()\n if k0 not in ['nin', 'nout', 'e1', 'e2']\n },\n dbragg=dict(self._dbragg),\n Name=f\"{self.Id.Name}{ii}\",\n Exp=self.Id.Exp,\n )\n for ii in range(nb)\n ]\n\n return lobj\n\n\n\n # -----------------\n # methods for general plotting\n # -----------------\n\n def plot(\n self, dcryst=None,\n phi=None, bragg=None, lamb=None, pts=None,\n n=None, config=None, det=None, length=None,\n dtheta=None, psi=None,\n ntheta=None, npsi=None,\n include_summit=None,\n dax=None, proj=None, res=None, element=None,\n color=None, ddet=None,\n dleg=None, draw=True, dmargin=None,\n use_non_parallelism=None, grid=None,\n rays_npts=None, rays_color=None,\n fs=None, wintit=None, tit=None,\n ):\n \"\"\" Plot the crystal in desired projeection\n\n The projection is 3d, cross-section or horizontal\n Optionaly add rays reflected on cryst at:\n - lamb / phi: desired wavelength and incidence angle\n and either:\n - psi, dtheta : desired pts on the crystal surface\n - pts: emitted from desired pts (e.g.: in the plasma)\n (need to be refresh with get_rays_from_cryst method\n if new pts are wanted)\n\n Parameters\n ----------\n dax: None / dict\n dict of axes to be used, with keys:\n - 'cross': axe where to plot cross-section view\n - 'hor': axe where to plot horizontal (from top) view\n - '3d': axe where to plot 3d view\n if None, a new figure and axes are created\n proj: None / str\n key indicating which plot to make:\n - 'cross': cross-section projection\n - 'hor': horizontal projection\n - 'all': cross-section + horizontal view\n - '3d': 3d view\n element: None / str\n char string where each letter indicates an element to plot\n - 'o': outline (edges of crystal)\n - 's': summit (geometrical center of the crystal)\n - 'c': center (of the sphere of curvature)\n - 'r': rowland circle (plotted in e1 direction)\n - 'v': local unit vectors e1, e2, nout\n If None, default to 'oscvr'\n res: None / float\n Resolution for the discretization of the outline\n dcryst: None / dict\n dict of dict for plotting the various elements of the crystal:\n - 'outline': dict of properties fed to plot()\n - 'cent': dict of properties fed to plot()\n - 'summit': dict of properties fed to plot()\n - 'rowland': dict of properties fed to plot()\n - 'vectors': dict of properties fed to quiver()\n ddet: None / dict\n dict of dict for plotting the various elements of the det:\n - 'outline': dict of properties fed to plot()\n - 'cent': dict of properties fed to plot()\n - 'vectors': dict of properties fed to quiver()\n color: None / str / tuple\n color to be used for plotting\n Overwrites all colors in dcryst and ddet\n det: None / dict\n Optionnal associated detector to be plotted, as a dict with keys:\n - 'cent': 1d array of cartesian coordinates of the center\n - 'nout': 1d array of cartesian coordinates of unit vector\n oriented towards the crystal\n - 'ei': 1d array of cartesian coordinates of unit vector\n - 'ej': 1d array of cartesian coordinates of unit vector\n - 'outline': 2d array of outline coordinates in (ei, ej)\n dleg: None / dict\n dict of properties to be passed to plt.legend()\n if False legend is not plotted\n use_non_parallelism: None / str\n Return the unit vectors (direct orthonormal basis)\n Depending on:\n - use_non_parallelism: True => return the geometrical basis\n - use_non_parallelism: False => return the mesh basis\n \"\"\"\n if det is None:\n det = False\n det = self._checkformat_det(det)\n\n lc = [\n dtheta is not None or psi is not None or phi is not None,\n pts is not None\n ]\n if np.sum(lc) == 2:\n msg = (\n \"For ray tracing, please provide either:\\n\"\n + \"\\t- dtheta, psi, phi, lamb/bragg\\n\"\n + \"\\t- pts, lamb/bragg\\n\"\n )\n raise Exception(msg)\n\n # Add rays?\n if lc[0]:\n # Get one way\n # pts.shape = (3, nlamb, npts, ndtheta)\n pts_summit, pts1 = self.get_rays_from_cryst(\n phi=phi, lamb=lamb, bragg=bragg,\n n=n, use_non_parallelism=use_non_parallelism,\n dtheta=dtheta, psi=psi,\n ntheta=ntheta, npsi=npsi,\n include_summit=include_summit,\n config=config, det=det,\n returnas='pts', return_xixj=False,\n grid=grid,\n )\n # Get the other way\n pts2, xi, xj = self.get_rays_from_cryst(\n phi=phi+np.pi, lamb=lamb, bragg=bragg,\n n=n, use_non_parallelism=use_non_parallelism,\n dtheta=dtheta, psi=psi,\n ntheta=ntheta, npsi=npsi,\n include_summit=include_summit,\n config=config, det=det,\n returnas='pts', return_xixj=True,\n grid=grid,\n )[1:]\n elif lc[1]:\n c0 = (\n isinstance(pts, np.ndarray)\n and pts.ndim == 2\n and pts.shape[0] == 3\n )\n if not c0:\n msg = (\"Arg pts must be a (3, npts) np.array!\")\n raise Exception(msg)\n\n # pts.shape = (nlamb, npts, ndtheta)\n dtheta, psi, phi, bragg, _, _ = self.calc_raytracing_from_lambpts(\n pts=pts,\n lamb=lamb,\n ndtheta=ntheta,\n )\n pts_summit, pts2, xi, xj = self.get_rays_from_cryst(\n phi=phi+np.pi, lamb=None, bragg=bragg,\n n=n, use_non_parallelism=use_non_parallelism,\n dtheta=dtheta, psi=psi,\n ntheta=ntheta, npsi=npsi,\n include_summit=include_summit,\n config=config, det=det,\n returnas='pts', return_xixj=True,\n grid=grid,\n )\n pts1 = np.repeat(\n np.repeat(\n np.repeat(\n pts[:, None, :], dtheta.shape[0], axis=1,\n )[..., None],\n dtheta.shape[2],\n axis=-1,\n )[..., None],\n 2,\n axis=-1,\n )\n else:\n pts_summit, pts1, pts2, xi, xj = None, None, None, None, None\n return _plot_optics.CrystalBragg_plot(\n cryst=self, dcryst=dcryst,\n det=det, ddet=ddet,\n dax=dax, proj=proj, res=res, element=element,\n color=color,\n pts_summit=pts_summit, pts1=pts1, pts2=pts2,\n xi=xi, xj=xj,\n rays_color=rays_color, rays_npts=rays_npts,\n dleg=dleg, draw=draw, fs=fs, dmargin=dmargin,\n use_non_parallelism=use_non_parallelism,\n wintit=wintit, tit=tit,\n )\n\n # -----------------\n # methods for generic first-approx\n # -----------------\n\n def get_phi_from_magaxis_summit(\n self,\n axis_r,\n axis_z,\n axis_npts=None,\n lamb=None,\n lamb_tol=None,\n bragg=None,\n n=None,\n use_non_parallelism=None,\n ):\n \"\"\" Return phi of a magnteic axis (at lamb with tolerance)\n\n axis_r and axis_z must be np.ndarrays of the same shape\n The magnetic axis is discretized toroidally in axis_npts (def: 1000)\n\n The pts closest to the chosen lamb are picked\n If no pts is found within tolerance, an error is raised\n\n \"\"\"\n\n # --------------------\n # Check / format input\n\n if axis_npts is None:\n axis_npts = 1000\n\n axis_r = np.atleast_1d(axis_r)\n axis_z = np.atleast_1d(axis_z)\n assert axis_r.shape == axis_z.shape\n\n if lamb_tol is None:\n lamb_tol = 0.01e-10\n\n bragg = self._checkformat_bragglamb(bragg=bragg, lamb=lamb, n=n)\n lamb = self.get_lamb_from_bragg(bragg=bragg, n=n)\n\n # --------------\n # Disretize axis\n\n shaperz = axis_r.shape\n phi_ax = np.full(shaperz, np.nan)\n\n # Compute phi\n theta_cryst = np.arctan2(\n self._dgeom['summit'][1],\n self._dgeom['summit'][0],\n )\n\n theta_ax = theta_cryst + np.pi/2*np.linspace(-1, 1, axis_npts)\n shapetheta = np.r_[[1 for ii in shaperz], axis_npts]\n theta_ax = theta_ax.reshape(shapetheta)\n\n axis_x = (axis_r[..., None] * np.cos(theta_ax)).ravel()\n axis_y = (axis_r[..., None] * np.sin(theta_ax)).ravel()\n axis_z = (np.repeat(axis_z[..., None], axis_npts, axis=-1)).ravel()\n\n # ----------------------------------------------\n # Compute bragg, phi, lamb of each point on axis\n\n (\n bragg_ax_full, phi_ax_full, lamb_ax_full,\n ) = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n pts=np.array([axis_x, axis_y, axis_z]),\n dtheta=None, psi=None,\n ntheta=None, npsi=None,\n n=None,\n use_non_parallelism=use_non_parallelism,\n grid=None,\n return_lamb=True,\n )\n\n # -------------------------------------\n # Select points on axis closest to lamb\n\n # lamb_ax_full = self.get_lamb_from_bragg(bragg_ax_full)\n shape_full = tuple(np.r_[shaperz, axis_npts])\n lamb_ax_full = lamb_ax_full.reshape(shape_full)\n phi_ax_full = phi_ax_full.reshape(shape_full)\n dlamb = np.abs(lamb_ax_full - lamb)\n\n indok = np.any(dlamb <= lamb_tol, axis=-1)\n indmin = np.nanargmin(dlamb[indok, :], axis=-1)\n indtup = tuple([iii for iii in indok.nonzero()] + [indmin])\n phi_ax[indok] = phi_ax_full[indtup]\n\n return phi_ax\n\n def get_bragg_from_lamb(self, lamb=None, n=None):\n \"\"\" Braggs' law: n*lamb = 2dsin(bragg) \"\"\"\n if self._dmat['d'] is None:\n msg = \"Interplane distance d no set !\\n\"\n msg += \" => self.set_dmat({'d':...})\"\n raise Exception(msg)\n if lamb is None:\n lamb = self._dbragg['lambref']\n return _comp_optics.get_bragg_from_lamb(\n np.atleast_1d(lamb), self._dmat['d'], n=n,\n )\n\n def get_lamb_from_bragg(self, bragg=None, n=None):\n \"\"\" Braggs' law: n*lamb = 2dsin(bragg) \"\"\"\n if self._dmat['d'] is None:\n msg = \"Interplane distance d no set !\\n\"\n msg += \" => self.set_dmat({'d':...})\"\n raise Exception(msg)\n if bragg is None:\n bragg = self._dbragg['braggref']\n return _comp_optics.get_lamb_from_bragg(np.atleast_1d(bragg),\n self._dmat['d'], n=n)\n\n def update_non_parallelism(self, alpha=None, beta=None):\n \"\"\" Compute new values of unit vectors nout, e1 and e2 into\n dmat basis, due to non parallelism\n\n Update new values into dmat dict\n \"\"\"\n if alpha is None:\n alpha = 0\n if beta is None:\n beta = 0\n\n (self._dmat['nin'], self._dmat['nout'], self._dmat['e1'],\n self._dmat['e2']) = _comp_optics.get_vectors_from_angles(\n alpha, beta,\n self._dgeom['nout'], self._dgeom['e1'],\n self._dgeom['e2'],\n )\n self._dmat['alpha'], self._dmat['beta'] = alpha, beta\n\n def calc_meridional_sagital_focus(\n self,\n rcurve=None,\n bragg=None,\n alpha=None,\n use_non_parallelism=None,\n verb=None,\n ):\n \"\"\" Compute sagittal and meridional focuses distances.\n Optionnal result according to non-parallelism, using first the\n update_non_parallelism method.\n\n parameters\n ----------\n rcurve: float\n in dgeom dict., curvature radius of the crystal.\n bragg: float\n in dbragg dict., reference bragg angle of the crystal.\n alpha: float\n in dmat dict., amplitude of the non-parallelism\n as an a angle defined by user, in radian.\n use_non_parallelism: str\n Need to be True to use new alpha angle\n\n Return\n ------\n merid_ref: float\n Distance crystal-meridional focus (m), for a perfect crystal\n sagit_ref: float\n Distance crystal-sagital focus (m), for a perfect crystal\n merid_unp: float\n Distance crystal-meridional focus (m), using non_parallelism\n sagit_unp: float\n Distance crystal-sagital focus (m), using non_parallelism\n\n \"\"\"\n # Check inputs\n if rcurve is None:\n rcurve = self._dgeom['rcurve']\n if bragg is None:\n bragg = self._dbragg['braggref']\n if use_non_parallelism is True:\n alpha = self._dmat['alpha']\n if use_non_parallelism is False:\n alpha = 0.0\n\n # Compute\n return _comp_optics.calc_meridional_sagital_focus(\n rcurve=rcurve,\n bragg=bragg,\n alpha=alpha,\n use_non_parallelism=use_non_parallelism,\n verb=verb,\n )\n\n def get_rowland_dist_from_lambbragg(self, bragg=None, lamb=None, n=None):\n \"\"\" Return the array of dist from cryst summit to pts on rowland \"\"\"\n bragg = self._checkformat_bragglamb(bragg=bragg, lamb=lamb, n=n)\n if np.all(np.isnan(bragg)):\n msg = (\"There is no available bragg angle!\\n\"\n + \" => Check the vlue of self.dmat['d'] vs lamb\")\n raise Exception(msg)\n return _comp_optics.get_rowland_dist_from_bragg(\n bragg=bragg, rcurve=self._dgeom['rcurve'],\n )\n\n def get_detector_ideal(\n self,\n bragg=None, lamb=None,\n rcurve=None, n=None,\n ddist=None, di=None, dj=None,\n dtheta=None, dpsi=None, tilt=None,\n lamb0=None, lamb1=None, dist01=None,\n use_non_parallelism=None,\n tangent_to_rowland=None, plot=False,\n ):\n \"\"\" Return approximate ideal detector geometry\n\n Assumes infinitesimal and ideal crystal\n Returns a dict containing the position and orientation of a detector if\n it was placed ideally on the rowland circle, centered on the\n desired bragg angle (in rad) or wavelength (in m)\n The detector can be tangential to the Rowland circle or perpendicular\n to the line between the crystal and the detector\n Assumes detector center matching lamb (m) / bragg (rad)\n\n The detector can be translated towards / away from the crystal\n to make sure the distance between 2 spectral lines\n\n (lamb0 and lamb1) on the detector's plane matches\n a desired distance (dist01, in m)\n\n Finally, a desired offset (translation) can be added\n via (ddist, di, dj), in m\n Similarly, an extra rotation can be added via (dtheta, dpsi, tilt)\n\n Detector is described by center position\n and (nout, ei, ej) unit vectors\n By convention, nout = np.cross(ei, ej)\n Vectors (ei, ej) define an orthogonal frame in the detector's plane\n All coordinates are 3d (X, Y, Z in the tokamak's frame)\n\n Return:\n -------\n det: dict\n dict of detector geometrical characteristics:\n 'cent': np.ndarray\n (3,) array of (x, y, z) coordinates of detector center\n 'nout': np.ndarray\n (3,) array of (x, y, z) coordinates of unit vector\n perpendicular to detector' surface\n oriented towards crystal\n 'ei': np.ndarray\n (3,) array of (x, y, z) coordinates of unit vector\n defining first coordinate in detector's plane\n 'ej': np.ndarray\n (3,) array of (x, y, z) coordinates of unit vector\n defining second coordinate in detector's plane\n 'outline': np.darray\n (2, N) array to build detector's contour\n where the last point is identical to the first.\n (for example for WEST X2D spectrometer:\n x*np.r_[-1,-1,1,1,-1], y*np.r_[-1,1,1,-1,-1])\n \"\"\"\n\n # ---------------------\n # Check / format inputs\n\n if rcurve is None:\n rcurve = self._dgeom['rcurve']\n\n bragg = self._checkformat_bragglamb(bragg=bragg, lamb=lamb, n=n)\n if np.all(np.isnan(bragg)):\n msg = (\"There is no available bragg angle!\\n\"\n + \" => Check the vlue of self.dmat['d'] vs lamb\")\n raise Exception(msg)\n\n lc = [lamb0 is not None, lamb1 is not None, dist01 is not None]\n if any(lc) and not all(lc):\n msg = (\n \"Arg lamb0, lamb1 and dist01 must be provided together:\\n\"\n + \"\\t- lamb0: line0 wavelength ({})\\n\".format(lamb0)\n + \"\\t- lamb1: line1 wavelength ({})\\n\".format(lamb1)\n + \"\\t- dist01: distance (m) on detector between lines \"\n + \"({})\".format(dist01)\n )\n raise Exception(msg)\n bragg01 = None\n if all(lc):\n bragg01 = self._checkformat_bragglamb(\n lamb=np.r_[lamb0, lamb1], n=n,\n )\n\n # split into 2 different condition because of dmat\n lc = [rcurve is None, self._dgeom['summit'] is None]\n if any(lc):\n msg = (\n \"Some missing fields in dgeom for computation:\"\n + \"\\n\\t-\" + \"\\n\\t-\".join(['rcurve'] + 'summit')\n )\n raise Exception(msg)\n\n nout, e1, e2, use_non_parallelism = self.get_unit_vectors(\n use_non_parallelism=use_non_parallelism,\n )\n\n lc = [cc is None for cc in [nout, e1, e2]]\n if any(lc):\n msg = (\n \"\"\"\n Field 'nout', 'e1', 'e2' missing!\n \"\"\"\n )\n raise Exception(msg)\n\n # Compute crystal-centered parameters in (nout, e1, e2)\n (det_dist, n_crystdet_rel,\n det_nout_rel, det_ei_rel) = _comp_optics.get_approx_detector_rel(\n rcurve, bragg,\n bragg01=bragg01, dist01=dist01,\n tangent_to_rowland=tangent_to_rowland)\n\n # Deduce absolute position in (x, y, z)\n det_cent, det_nout, det_ei, det_ej = _comp_optics.get_det_abs_from_rel(\n det_dist, n_crystdet_rel, det_nout_rel, det_ei_rel,\n self._dgeom['summit'], nout, e1, e2,\n ddist=ddist, di=di, dj=dj,\n dtheta=dtheta, dpsi=dpsi, tilt=tilt)\n\n if plot:\n dax = self.plot()\n p0 = np.repeat(det_cent[:,None], 3, axis=1)\n vv = np.vstack((det_nout, det_ei, det_ej)).T\n dax['cross'].plot(np.hypot(det_cent[0], det_cent[1]),\n det_cent[2], 'xb')\n dax['hor'].plot(det_cent[0], det_cent[1], 'xb')\n dax['cross'].quiver(np.hypot(p0[0, :], p0[1, :]), p0[2, :],\n np.hypot(vv[0, :], vv[1, :]), vv[2, :],\n units='xy', color='b')\n dax['hor'].quiver(p0[0, :], p0[1, :], vv[0, :], vv[1, :],\n units='xy', color='b')\n return {'cent': det_cent, 'nout': det_nout,\n 'ei': det_ei, 'ej': det_ej}\n\n def _checkformat_det(self, det=None):\n lc = [det is None, det is False, isinstance(det, dict)]\n msg = (\"det must be:\\n\"\n + \"\\t- False: not det provided\\n\"\n + \"\\t- None: use default approx det from:\\n\"\n + \"\\t self.get_detector_ideal()\\n\"\n + \"\\t- dict: a dictionary of 3d (x,y,z) coordinates of a point\"\n + \" (local frame center) and 3 unit vectors forming a direct \"\n + \"orthonormal basis attached to the detector's frame\\n\"\n + \"\\t\\t\\t\\t- 'cent': detector center\\n\"\n + \"\\t\\t\\t\\t- 'nout': unit vector perpendicular to surface, \"\n + \"in direction of the crystal\\n\"\n + \"\\t\\t\\t\\t- 'ei': unit vector, first coordinate on surface\\n\"\n + \"\\t\\t\\t\\t- 'ej': unit vector, second coordinate on surfacei\\n\"\n + \" You provided: {}\".format(det))\n if not any(lc):\n raise Exception(msg)\n if lc[0]:\n det = self.get_detector_ideal(lamb=self._dbragg['lambref'])\n elif lc[2]:\n lk = ['cent', 'nout', 'ei', 'ej']\n c0 = (isinstance(det, dict)\n and all([(kk in det.keys()\n and hasattr(det[kk], '__iter__')\n and np.atleast_1d(det[kk]).size == 3\n and not np.any(np.isnan(det[kk])))\n for kk in lk]))\n if not c0:\n raise Exception(msg)\n for k0 in lk:\n det[k0] = np.atleast_1d(det[k0]).ravel()\n return det\n\n def get_local_noute1e2(\n self,\n dtheta=None, psi=None,\n ntheta=None, npsi=None,\n use_non_parallelism=None,\n include_summit=None,\n ):\n \"\"\" Return (vout, ve1, ve2) associated to pts on the crystal's surface\n\n All points on the spherical crystal's surface are identified\n by (dtheta, psi) coordinates, where:\n - theta = np.pi/2 + dtheta (dtheta=0 default) for the center\n (for the diffracted beam), from frame's basis vector ez\n - psi = 0 for the center, positive in direction of e1\n They are the spherical coordinates from a sphere centered on the\n crystal's center of curvature.\n\n Args (dtheta, psi) can be:\n - arbitrary: same shape and dimension up to 4\n - 'envelop': will be computed to represent the crystal contour\n will be returned as 2 1d arrays\n\n Return the pts themselves and the 3 perpendicular local unit vectors\n (nout, e1, e2), where nout is towards the outside of the sphere and\n nout = np.cross(e1, e2)\n\n In all cases, the output have shape (3, psi.shape)\n\n Return:\n -------\n summ: np.ndarray\n coordinates of the points on the surface\n vout: np.ndarray\n coordinates of outward unit vector\n ve1: np.ndarray\n coordinates of first tangential unit vector\n ve2: np.ndarray\n coordinates of second tangential unit vector\n\n All are cartesian (X, Y, Z) coordinates in the tokamak's frame\n\n \"\"\"\n # Get local basis at crystal summit\n nout, e1, e2, use_non_parallelism = self.get_unit_vectors(\n use_non_parallelism=use_non_parallelism,\n )\n nin = -nout\n\n # Get vectors at any points from psi & dtheta\n vout, ve1, ve2 = _comp_optics.CrystBragg_get_noute1e2_from_psitheta(\n nout, e1, e2,\n psi=psi, dtheta=dtheta,\n e1e2=True, sameshape=False,\n extenthalf_psi=self._dgeom['extenthalf'][0],\n extenthalf_dtheta=self._dgeom['extenthalf'][1],\n ntheta=ntheta, npsi=npsi,\n include_summit=include_summit,\n )\n vin = -vout\n # cent no longer dgeom['center'] because no longer a fixed point\n cent = self._dgeom['summit'] + self._dgeom['rcurve']*nin\n reshape = np.r_[3, [1 for ii in range(vout.ndim - 1)]]\n cent = cent.reshape(reshape)\n\n # Redefining summit according to nout at each point at crystal\n summ = cent + self._dgeom['rcurve']*vout\n return summ, vout, ve1, ve2\n\n def calc_xixj_from_braggphi(\n self,\n phi=None,\n bragg=None,\n lamb=None,\n n=None,\n dtheta=None,\n psi=None,\n det=None,\n use_non_parallelism=None,\n strict=None,\n return_strict=None,\n data=None,\n plot=True,\n dax=None,\n ):\n \"\"\" Assuming crystal's summit as frame origin\n\n According to [1], this assumes a local frame centered on the crystal\n\n These calculations are independent from the tokamak's frame:\n The origin of the local frame is the crystal's summit\n The (O, ez) axis is the crystal's normal\n The crystal is tangent to (O, ex, ey)\n\n [1] tofu/Notes_Upgrades/SpectroX2D/SpectroX2D_EllipsesOnPlane.pdf\n\n Parameters:\n -----------\n Z: float\n Detector's plane intersection with (O, ez) axis\n n: np.ndarray\n (3,) array containing local (x,y,z) coordinates of the plane's\n normal vector\n \"\"\"\n if return_strict is None:\n return_strict = False\n\n # Check / format inputs\n bragg = self._checkformat_bragglamb(bragg=bragg, lamb=lamb, n=n)\n phi = np.atleast_1d(phi)\n\n # Check / get det\n det = self._checkformat_det(det)\n\n # Get local summit nout, e1, e2 if non-centered\n if dtheta is None:\n dtheta = 0.\n if psi is None:\n psi = 0.\n\n # Probably to update with use_non_parallelism?\n # Get back summit & vectors at any point at the crystal surface,\n # according to parallelism properties\n summit, nout, e1, e2 = self.get_local_noute1e2(\n dtheta=dtheta, psi=psi,\n use_non_parallelism=use_non_parallelism,\n ntheta=None, npsi=None,\n include_summit=False,\n )\n\n # Compute\n xi, xj, strict = _comp_optics.calc_xixj_from_braggphi(\n det_cent=det['cent'],\n det_nout=det['nout'], det_ei=det['ei'], det_ej=det['ej'],\n det_outline=det.get('outline'),\n summit=summit, nout=nout, e1=e1, e2=e2,\n bragg=bragg, phi=phi, strict=strict,\n )\n\n if plot:\n dax = _plot_optics.CrystalBragg_plot_approx_detector_params(\n bragg, xi, xj, data, dax,\n )\n if return_strict is True:\n return xi, xj, strict\n else:\n return xi, xj\n\n def plot_line_on_det_tracing(\n self, lamb=None, n=None,\n nphi=None,\n det=None, johann=None,\n use_non_parallelism=None,\n lpsi=None, ldtheta=None,\n strict=None,\n ax=None, dleg=None,\n rocking=None, fs=None, dmargin=None,\n wintit=None, tit=None,\n ):\n \"\"\" Visualize the de-focusing by ray-tracing of chosen lamb\n Possibility to plot few wavelength' arcs on the same plot.\n Args:\n - lamb: array of min size 1, in 1e-10 [m]\n - det: dict\n - xi_bounds: np.min & np.max of _XI\n - xj_bounds: np.min & np.max of _XJ\n (from \"inputs_temp/XICS_allshots_C34.py\" l.649)\n - johann: True or False\n \"\"\"\n # Check / format inputs\n if lamb is None:\n lamb = self._dbragg['lambref']\n lamb = np.atleast_1d(lamb).ravel()\n nlamb = lamb.size\n\n if johann is None:\n johann = lpsi is not None or ldtheta is not None\n if rocking is None:\n rocking = False\n\n if det is None or det.get('outline') is None:\n msg = (\"Please provide det as a dict with 'outline'!\")\n raise Exception(msg)\n\n # Get local basis\n nout, e1, e2, use_non_parallelism = self.get_unit_vectors(\n use_non_parallelism=use_non_parallelism,\n )\n nin = -nout\n\n # Compute lamb / phi\n _, phi = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n xi=det['outline'][0, :], xj=det['outline'][1, :], det=det,\n dtheta=0, psi=0,\n use_non_parallelism=use_non_parallelism,\n n=n,\n grid=True,\n return_lamb=False,\n )\n phimin, phimax = np.nanmin(phi), np.nanmax(phi)\n phimin, phimax = phimin-(phimax-phimin)/10, phimax+(phimax-phimin)/10\n\n # Get reference ray-tracing\n bragg = self._checkformat_bragglamb(lamb=lamb, n=n)\n if nphi is None:\n nphi = 100\n phi = np.linspace(phimin, phimax, nphi)\n\n xi = np.full((nlamb, nphi), np.nan)\n xj = np.full((nlamb, nphi), np.nan)\n for ll in range(nlamb):\n xi[ll, :], xj[ll, :] = self.calc_xixj_from_braggphi(\n bragg=np.full(phi.shape, bragg[ll]),\n phi=phi,\n dtheta=0.,\n psi=0.,\n n=n,\n det=det,\n use_non_parallelism=use_non_parallelism,\n strict=strict,\n plot=False,\n )\n\n # Get johann-error raytracing (multiple positions on crystal)\n xi_er, xj_er = None, None\n if johann and not rocking:\n if lpsi is None:\n lpsi = np.linspace(-1., 1., 15)\n if ldtheta is None:\n ldtheta = np.linspace(-1., 1., 15)\n lpsi, ldtheta = np.meshgrid(lpsi, ldtheta)\n lpsi = lpsi.ravel()\n ldtheta = ldtheta.ravel()\n\n lpsi = self._dgeom['extenthalf'][0]*np.r_[lpsi]\n ldtheta = self._dgeom['extenthalf'][1]*np.r_[ldtheta]\n npsi = lpsi.size\n assert npsi == ldtheta.size\n\n xi_er = np.full((nlamb, npsi*nphi), np.nan)\n xj_er = np.full((nlamb, npsi*nphi), np.nan)\n for l in range(nlamb):\n for ii in range(npsi):\n i0 = np.arange(ii*nphi, (ii+1)*nphi)\n xi_er[l, i0], xj_er[l, i0] = self.calc_xixj_from_braggphi(\n phi=phi, bragg=bragg[l], lamb=None, n=n,\n dtheta=ldtheta[ii], psi=lpsi[ii],\n det=det, plot=False,\n use_non_parallelism=use_non_parallelism,\n strict=strict,\n )\n\n # Get rocking curve error\n if rocking:\n pass\n\n # Plot\n return _plot_optics.CrystalBragg_plot_line_tracing_on_det(\n lamb, xi, xj, xi_er, xj_er,\n det=det, ax=ax, dleg=dleg,\n johann=johann, rocking=rocking,\n fs=fs, dmargin=dmargin, wintit=wintit, tit=tit)\n\n def calc_johannerror(\n self,\n xi=None, xj=None, err=None,\n det=None, n=None,\n lpsi=None, ldtheta=None,\n lambda_interval_min=None,\n lambda_interval_max=None,\n use_non_parallelism=None,\n plot=True, fs=None, cmap=None,\n vmin=None, vmax=None, tit=None, wintit=None,\n ):\n \"\"\" Plot the johann error\n\n The johann error is the error (scattering) induced by defocalization\n due to finite crystal dimensions\n There is a johann error on wavelength (lamb => loss of spectral\n resolution) and on directionality (phi)\n If provided, lpsi and ldtheta are taken as normalized variations with\n respect to the crystal summit and to its extenthalf.\n Typical values are:\n - lpsi = [-1, 1, 1, -1]\n - ldtheta = [-1, -1, 1, 1]\n They must have the same len()\n\n First affecting a reference lambda according to:\n - pixel's position\n - crystal's summit\n Then, computing error on bragg and phi angles on each pixels by\n computing lambda and phi from the crystal's outline\n Provide lambda_interval_min/max to ensure the given wavelength interval\n is detected over the whole surface area.\n A True/False boolean is then returned.\n \"\"\"\n\n # Check xi, xj once before to avoid doing it twice\n if err is None:\n err = 'abs'\n if lambda_interval_min is None:\n lambda_interval_min = 3.93e-10\n if lambda_interval_max is None:\n lambda_interval_max = 4.00e-10\n\n xi, xj, (xii, xjj) = _comp_optics._checkformat_xixj(xi, xj)\n\n # Check / format inputs\n bragg, phi, lamb = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n xi=xii, xj=xjj, det=det,\n dtheta=0, psi=0,\n use_non_parallelism=use_non_parallelism,\n n=n,\n grid=True,\n return_lamb=True,\n )\n\n # Only one summit was selected\n bragg, phi, lamb = bragg[..., 0], phi[..., 0], lamb[..., 0]\n\n # Check lambda interval into lamb array\n c0 = (\n np.min(lamb) < lambda_interval_min\n and np.max(lamb) > lambda_interval_max\n )\n if c0:\n test_lambda_interv = True\n else:\n test_lambda_interv = False\n\n # Get err from multiple ldtheta, lpsi\n if lpsi is None:\n lpsi = np.r_[-1., 0., 1., 1., 1., 0., -1, -1]\n lpsi = self._dgeom['extenthalf'][0]*np.r_[lpsi]\n if ldtheta is None:\n ldtheta = np.r_[-1., -1., -1., 0., 1., 1., 1., 0.]\n ldtheta = self._dgeom['extenthalf'][1]*np.r_[ldtheta]\n npsi = lpsi.size\n assert npsi == ldtheta.size\n\n (\n braggerr, phierr, lamberr,\n ) = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n xi=xii, xj=xjj, det=det,\n dtheta=ldtheta, psi=lpsi,\n use_non_parallelism=use_non_parallelism,\n n=n,\n grid=True,\n return_lamb=True,\n )\n err_lamb = np.nanmax(np.abs(lamb[..., None] - lamberr), axis=-1)\n err_phi = np.nanmax(np.abs(phi[..., None] - phierr), axis=-1)\n\n # absolute vs relative error\n if 'rel' in err:\n if err == 'rel':\n err_lamb = 100.*err_lamb / (np.nanmax(lamb) - np.nanmin(lamb))\n err_phi = 100.*err_phi / (np.nanmax(phi) - np.nanmin(phi))\n elif err == 'rel2':\n err_lamb = 100.*err_lamb / np.mean(lamb)\n err_phi = 100.*err_phi / np.mean(phi)\n err_lamb_units = '%'\n err_phi_units = '%'\n else:\n err_lamb_units = 'm'\n err_phi_units = 'rad'\n\n if plot is True:\n ax = _plot_optics.CrystalBragg_plot_johannerror(\n xi, xj, lamb, phi,\n err_lamb, err_phi,\n err_lamb_units=err_lamb_units,\n err_phi_units=err_phi_units,\n cmap=cmap, vmin=vmin, vmax=vmax,\n fs=fs, tit=tit, wintit=wintit,\n )\n return (\n err_lamb, err_phi, err_lamb_units, err_phi_units,\n test_lambda_interv,\n )\n\n def plot_focal_error_summed(\n self,\n dist_min=None, dist_max=None,\n di_min=None, di_max=None,\n ndist=None, ndi=None,\n lamb=None, bragg=None,\n xi=None, xj=None,\n err=None,\n use_non_parallelism=None,\n tangent_to_rowland=None, n=None,\n plot=None,\n pts=None,\n det_ref=None, plot_dets=None, nsort=None,\n dcryst=None,\n lambda_interval_min=None,\n lambda_interval_max=None,\n contour=None,\n fs=None,\n ax=None,\n cmap=None,\n vmin=None,\n vmax=None,\n return_ax=None,\n ):\n \"\"\"\n Using the calc_johannerror method, computing the sum of the\n focalization error over the whole detector for different positions\n characterized by the translations ddist and di in the equatorial plane\n (dist_min, dist_max, ndist) (di_min, di_max, ndi).\n\n Parameters:\n -----------\n - lamb/bragg : float\n Automatically set to crystal's references\n - xi, xj : np.ndarray\n pixelization of the detector\n (from \"inputs_temp/XICS_allshots_C34.py\" l.649)\n - alpha, beta : float\n Values of Non Parallelism references angles\n - use_non_parallelism : str\n - tangent_to_rowland : str\n - plot_dets : str\n Possibility to plot the nsort- detectors with the lowest\n summed focalization error, next to the Best Approximate Real\n detector\n dict(np.load('det37_CTVD_incC4_New.npz', allow_pickle=True))\n - nsort : float\n Number of best detector's position to plot\n - lambda_interv_min/max : float\n To ensure the given wavelength interval is detected over the whole\n surface area. A True/False boolean is then returned.\n \"\"\"\n\n # Check / format inputs\n if dist_min is None:\n dist_min = -0.15\n if dist_max is None:\n dist_max = 0.15\n if di_min is None:\n di_min = -0.40\n if di_max is None:\n di_max = 0.40\n if ndist is None:\n ndist = 21\n if ndi is None:\n ndi = 21\n if err is None:\n err = 'rel'\n if plot is None:\n plot = True\n if plot_dets is None:\n plot_dets = det_ref is not None\n if nsort is None:\n nsort = 5\n if return_ax is None:\n return_ax = True\n if lambda_interval_min is None:\n lambda_interval_min = 3.93e-10\n if lambda_interval_max is None:\n lambda_interval_max = 4.00e-10\n\n l0 = [dist_min, dist_max, ndist, di_min, di_max, ndi]\n c0 = any([l00 is not None for l00 in l0])\n if not c0:\n msg = (\n \"Please give the ranges of ddist and di translations\\n\"\n \"\\t to compute the different detector's position\\n\"\n \"\\t Provided:\\n\"\n \"\\t\\t- dist_min, dist_max, ndist: ({}, {}, {})\\n\".format(\n dist_min, dist_max, ndist,\n )\n + \"\\t\\t- di_min, di_max, ndi: ({}, {}, {})\\n\".format(\n di_min, di_max, ndi,\n )\n )\n raise Exception(msg)\n\n # ------------\n # Compute local coordinates of det_ref\n (\n ddist0, di0, dj0,\n dtheta0, dpsi0, tilt0,\n ) = self._get_local_coordinates_of_det(\n bragg=bragg,\n lamb=lamb,\n det_ref=det_ref,\n use_non_parallelism=use_non_parallelism,\n )\n\n # angle between nout vectors from get_det_approx() &\n ## get_det_approx(tangent=False)\n\n det1 = self.get_detector_ideal(\n lamb=lamb,\n bragg=bragg,\n use_non_parallelism=use_non_parallelism,\n tangent_to_rowland=True,\n )\n det2 = self.get_detector_ideal(\n lamb=lamb,\n bragg=bragg,\n use_non_parallelism=use_non_parallelism,\n tangent_to_rowland=False,\n )\n cos_angle_nout = np.sum(\n det1['nout'] * det2['nout']\n ) / (\n np.linalg.norm(det1['nout'] * np.linalg.norm(det2['nout']))\n )\n angle_nout = np.arccos(cos_angle_nout)\n\n # Compute\n ddist = np.linspace(dist_min, dist_max, int(ndist))\n di = np.linspace(di_min, di_max, int(ndi))\n error_lambda = np.full((di.size, ddist.size), np.nan)\n test_lamb_interv = np.zeros((di.size, ddist.size), dtype='bool')\n end = '\\r'\n for ii in range(ddist.size):\n for jj in range(di.size):\n\n # print progression\n if ii == ndist-1 and jj == ndi-1:\n end = '\\n'\n msg = (\n \"Computing mean focal error for det \"\n f\"({ii+1}, {jj+1})/({ndist}, {ndi})\"\n ).ljust(60)\n print(msg, end=end, flush=True)\n\n # Get det\n dpsi0bis = float(dpsi0)\n if tangent_to_rowland:\n dpsi0bis = dpsi0 - angle_nout\n\n det = self.get_detector_ideal(\n ddist=ddist[ii],\n di=di[jj],\n dj=dj0,\n dtheta=dtheta0,\n dpsi=dpsi0bis,\n tilt=tilt0,\n lamb=lamb,\n bragg=bragg,\n use_non_parallelism=use_non_parallelism,\n tangent_to_rowland=False,\n )\n\n # Integrate error\n (\n error_lambda_temp, test_lamb_interv[jj, ii],\n ) = self.calc_johannerror(\n xi=xi, xj=xj,\n det=det,\n err=err,\n lambda_interval_min=lambda_interval_min,\n lambda_interval_max=lambda_interval_max,\n plot=False,\n )[::4]\n error_lambda[jj, ii] = np.nanmean(error_lambda_temp)\n\n if 'rel' in err:\n units = '%'\n else:\n units = 'm'\n\n if plot:\n ax = _plot_optics.CrystalBragg_plot_focal_error_summed(\n cryst=self, dcryst=dcryst,\n lamb=lamb, bragg=bragg,\n error_lambda=error_lambda,\n ddist=ddist, di=di,\n ddist0=ddist0, di0=di0, dj0=dj0,\n dtheta0=dtheta0, dpsi0=dpsi0, tilt0=tilt0,\n angle_nout=angle_nout,\n det_ref=det_ref,\n units=units,\n plot_dets=plot_dets, nsort=nsort,\n tangent_to_rowland=tangent_to_rowland,\n use_non_parallelism=use_non_parallelism,\n pts=pts,\n test_lamb_interv=test_lamb_interv,\n contour=contour,\n fs=fs,\n ax=ax,\n cmap=cmap,\n vmin=vmin,\n vmax=vmax,\n )\n if return_ax:\n return error_lambda, ddist, di, test_lamb_interv, ax\n else:\n return error_lambda, ddist, di, test_lamb_interv\n\n def _get_local_coordinates_of_det(\n self,\n bragg=None,\n lamb=None,\n det_ref=None,\n use_non_parallelism=None,\n ):\n \"\"\"\n Computation of translation (ddist, di, dj) and angular\n (dtheta, dpsi, tilt) properties of an arbitrary detector choosen by\n the user.\n \"\"\"\n\n # ------------\n # check inputs\n\n if det_ref is None:\n msg = (\n \"You need to provide your arbitrary detector\\n\"\n + \"\\t in order to compute its spatial properties !\\n\"\n + \"\\t You provided: {}\".format(det)\n )\n raise Exception(msg)\n\n # Checkformat det\n det_ref = self._checkformat_det(det=det_ref)\n\n # ------------\n # get approx detect\n\n det_approx = self.get_detector_ideal(\n bragg=bragg, lamb=lamb,\n tangent_to_rowland=False,\n use_non_parallelism=use_non_parallelism,\n )\n\n # ------------\n # get vector delta between centers\n\n delta = det_ref['cent'] - det_approx['cent']\n ddist = np.sum(delta * (-det_approx['nout']))\n di = np.sum(delta * det_approx['ei'])\n dj = np.sum(delta * det_approx['ej'])\n\n # ---------------\n # get angles from unit vectors\n dtheta, dpsi, tilt = None, None, None\n\n # use formulas in _comp_optics.get_det_abs_from_rel()\n sindtheta = np.sum(det_approx['ej'] * det_ref['nout'])\n costheta_cospsi = np.sum(det_approx['nout'] * det_ref['nout'])\n costheta_sinpsi = np.sum(det_approx['ei'] * det_ref['nout'])\n costheta = np.sqrt(costheta_cospsi**2 + costheta_sinpsi**2)\n dtheta = np.arctan2(sindtheta, costheta)\n dpsi = np.arctan2(\n costheta_sinpsi / costheta,\n costheta_cospsi / costheta,\n )\n\n # ---------\n # tilt\n det_ei2 = (\n np.cos(dpsi)*det_approx['ei'] - np.sin(dpsi)*det_approx['nout']\n )\n det_ej2 = np.cross(det_ref['nout'], det_ei2)\n costilt = np.sum(det_ref['ei']*det_ei2)\n sintilt = np.sum(det_ref['ei']*det_ej2)\n tilt = np.arctan2(sintilt, costilt)\n\n return ddist, di, dj, dtheta, dpsi, tilt\n\n def get_lambbraggphi_from_ptsxixj_dthetapsi(\n self,\n pts=None,\n xi=None, xj=None, det=None,\n dtheta=None, psi=None,\n ntheta=None, npsi=None,\n n=None,\n use_non_parallelism=None,\n grid=None,\n return_lamb=None,\n ):\n \"\"\" Return the lamb, bragg and phi for provided pts and dtheta/psi\n\n if grid = True:\n compute all pts / dtheta/psi comnbinations\n => return (npts, ndtheta) arrays\n else:\n each pts is associated to a single dtheta/psi\n => assumes npts == ndtheta == npsi\n => return (npts,) arrays\n\n \"\"\"\n\n # Check / Format inputs\n if return_lamb is None:\n return_lamb = True\n det = self._checkformat_det(det)\n\n # Get local basis\n summ, vout, ve1, ve2 = self.get_local_noute1e2(\n dtheta=dtheta, psi=psi,\n ntheta=ntheta, npsi=npsi,\n use_non_parallelism=use_non_parallelism,\n include_summit=True,\n )\n\n # Derive bragg, phi\n bragg, phi = _comp_optics.calc_braggphi_from_xixjpts(\n pts=pts,\n xi=xi, xj=xj, det=det,\n summit=summ, nin=-vout, e1=ve1, e2=ve2,\n grid=grid,\n )\n\n # Derive lamb\n if return_lamb is True:\n lamb = self.get_lamb_from_bragg(bragg=bragg, n=n)\n return bragg, phi, lamb\n else:\n return bragg, phi\n\n def get_lamb_avail_from_pts(\n self,\n pts=None,\n n=None, ndtheta=None,\n det=None, nlamb=None, klamb=None,\n use_non_parallelism=None,\n strict=None,\n return_phidtheta=None,\n return_xixj=None,\n ):\n \"\"\" Return the wavelength accessible from plasma points on the crystal\n\n For a given plasma point, only a certain lambda interval can be\n bragg-diffracted on the crystal (due to bragg's law and the crystal's\n dimensions)\n\n Beware, for a given pts and lamb, there can be up to 2 sets of\n solutions\n All non-valid solutions are set to nans, such that most of the time\n there is only one\n\n For a set of given:\n - pts (3, npts) array, (x, y, z) coordinates\n Using:\n - nlamb: sampling of the lamb interval (default: 100)\n - ndtheta: sampling of the lamb interval (default: 20)\n - det: (optional) a detector dict, for xi and xj\n Returns:\n - lamb: (npts, nlamb) array of sampled valid wavelength interval\n - phi: (npts, nlamb, ndtheta, 2) array of phi\n - dtheta: (npts, nlamb, ndtheta, 2) array of dtheta\n - psi: (npts, nlamb, ndtheta, 2) array of psi\n And optionally (return_xixj=True and det provided as dict):\n - xi: (npts, nlamb, ndtheta, 2) array of xi\n - xj: (npts, nlamb, ndtheta, 2) array of xj\n\n The result is computed with or w/o taking into account non-parallelism\n\n \"\"\"\n # Check / format\n if ndtheta is None:\n ndtheta = 20\n if nlamb is None:\n nlamb = 100\n assert nlamb >= 2, \"nlamb must be >= 2\"\n if return_phidtheta is None:\n return_phidtheta = True\n if return_xixj is None:\n return_xixj = det is not None\n if det is None:\n return_xixj = False\n if det is None:\n strict = False\n\n # Get lamb min / max\n bragg, phi, lamb = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n pts=pts,\n dtheta='envelop', psi='envelop',\n ntheta=None, npsi=None,\n n=n, grid=True,\n use_non_parallelism=use_non_parallelism,\n return_lamb=True,\n )\n lambmin = np.nanmin(lamb, axis=1)\n lambmax = np.nanmax(lamb, axis=1)\n if klamb is None:\n klamb = np.linspace(0, 1, nlamb)\n elif not (isinstance(klamb, np.ndarray) and klamb.ndim == 1):\n msg = \"Please provide klamb as a 1d vector!\"\n raise Exception(msg)\n nlamb = klamb.size\n lamb = lambmin[:, None] + (lambmax-lambmin)[:, None]*klamb\n\n return _comp_optics._get_lamb_avail_from_pts_phidtheta_xixj(\n cryst=self,\n lamb=lamb,\n n=n,\n ndtheta=ndtheta,\n pts=pts,\n use_non_parallelism=use_non_parallelism,\n return_phidtheta=return_phidtheta,\n return_xixj=return_xixj,\n strict=strict,\n det=det,\n )\n\n def _calc_dthetapsiphi_from_lambpts(\n self,\n pts=None, bragg=None, lamb=None,\n n=None, ndtheta=None,\n use_non_parallelism=None,\n grid=None,\n ):\n\n # Check / Format inputs\n pts = _comp_optics._checkformat_pts(pts)\n npts = pts.shape[1]\n\n bragg = self._checkformat_bragglamb(bragg=bragg, lamb=lamb, n=n)\n\n # get nout, e1, e2\n nout, e1, e2, use_non_parallelism = self.get_unit_vectors(\n use_non_parallelism=use_non_parallelism\n )\n\n # Compute dtheta, psi, indnan (nlamb, npts, ndtheta)\n # In general there are 2 solutions! (only close to rowland in practice)\n dtheta, psi, indok, grid = _comp_optics.calc_dthetapsiphi_from_lambpts(\n pts,\n bragg,\n summit=self._dgeom['summit'], # To be updated (non-paralellism)?\n rcurve=self._dgeom['rcurve'],\n nout=nout, e1=e1, e2=e2,\n extenthalf=self._dgeom['extenthalf'],\n ndtheta=ndtheta,\n grid=grid,\n )\n\n # reshape bragg for matching dtheta.shape\n if grid is True:\n bragg = np.repeat(\n np.repeat(\n np.repeat(bragg[:, None], npts, axis=-1)[..., None],\n dtheta.shape[2],\n axis=-1,\n )[..., None],\n 2,\n axis=-1,\n )\n pts = pts[:, None, :, None, None]\n else:\n bragg = np.repeat(\n np.repeat(bragg[:, None], dtheta.shape[1], axis=1)[..., None],\n 2,\n axis=-1,\n )\n pts = pts[..., None, None]\n bragg[~indok] = np.nan\n\n # Get corresponding phi and re-check bragg, for safety\n bragg2, phi = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n pts=pts,\n dtheta=dtheta, psi=psi,\n grid=False,\n use_non_parallelism=use_non_parallelism,\n return_lamb=False,\n )\n\n c0 = (\n bragg2.shape == bragg.shape\n and np.allclose(bragg, bragg2, equal_nan=True)\n )\n if not c0:\n try:\n plt.figure()\n plt.plot(bragg, bragg2, '.')\n except Exception as err:\n pass\n msg = (\n \"Inconsistency detected in bragg angle computations:\\n\"\n + \"\\t- from the points and lamb\\n\"\n + \"\\t- from the points and (dtheta, psi)\\n\"\n + \"\\nContext:\\n\"\n + \"\\t- use_non_parallelism: {}\\n\".format(use_non_parallelism)\n + \"\\t- bragg.shape = {}\\n\".format(bragg.shape)\n + \"\\t- bragg2.shape = {}\\n\".format(bragg2.shape)\n )\n raise Exception(msg)\n\n return dtheta, psi, phi, bragg\n\n def calc_raytracing_from_lambpts(\n self,\n lamb=None, bragg=None, pts=None,\n xi_bounds=None, xj_bounds=None, nphi=None,\n det=None, n=None, ndtheta=None,\n johann=False, lpsi=None, ldtheta=None,\n rocking=False, strict=None, plot=None, fs=None,\n dmargin=None, wintit=None,\n tit=None, proj=None,\n legend=None, draw=None, returnas=None,\n ):\n \"\"\" Visualize the de-focusing by ray-tracing of chosen lamb\n\n If plot, 3 different plots can be produced:\n - det: plots the intersection of rays with detector plane\n - '2d': plots the geometry of the rays in 2d cross and hor\n - '3d': plots the geometry of the rays in 3d\n Specify the plotting option by setting plot to any of these (or a list)\n \"\"\"\n # Check / format inputs\n if returnas is None:\n returnas = 'data'\n if plot is None or plot is True:\n plot = ['det', '3d']\n if isinstance(plot, str):\n plot = plot.split('+')\n assert all([ss in ['det', '2d', '3d'] for ss in plot])\n assert returnas in ['data', 'ax']\n\n pts = _comp_optics._checkformat_pts(pts)\n npts = pts.shape[1]\n\n # Get dtheta, psi and phi from pts/lamb\n dtheta, psi, phi, bragg = self._calc_dthetapsiphi_from_lambpts(\n pts=pts, lamb=lamb, bragg=bragg, n=n, ndtheta=ndtheta,\n )\n ndtheta = dtheta.shape[-1]\n # assert dtheta.shape == (nlamb, npts, ndtheta)\n\n # Check / get det\n det = self._checkformat_det(det)\n\n # Compute xi, xj of reflexion (phi -> phi + np.pi)\n xi, xj = self.calc_xixj_from_braggphi(\n bragg=bragg, phi=phi+np.pi, n=n,\n dtheta=dtheta, psi=psi,\n det=det, strict=strict, plot=False,\n )\n\n # Plot to be checked - unnecessary ?\n plot = False\n if plot is not False:\n ptscryst, ptsdet = None, None\n if '2d' in plot or '3d' in plot:\n ptscryst = self.get_local_noute1e2(dtheta, psi)[0]\n ptsdet = (det['cent'][:, None, None, None]\n + xi[None, ...]*det['ei'][:, None, None, None]\n + xj[None, ...]*det['ej'][:, None, None, None])\n\n ax = _plot_optics.CrystalBragg_plot_raytracing_from_lambpts(\n xi=xi, xj=xj, lamb=lamb,\n xi_bounds=xi_bounds, xj_bounds=xj_bounds,\n pts=pts, ptscryst=ptscryst, ptsdet=ptsdet,\n det_cent=det['cent'], det_nout=det['nout'],\n det_ei=det['ei'], det_ej=det['ej'],\n cryst=self, proj=plot, fs=fs, dmargin=dmargin,\n wintit=wintit, tit=tit, legend=legend, draw=draw)\n if returnas == 'ax':\n return ax\n return dtheta, psi, phi, bragg, xi, xj\n\n def _calc_spect1d_from_data2d(self, data, lamb, phi,\n nlambfit=None, nphifit=None,\n nxi=None, nxj=None,\n spect1d=None, mask=None, vertsum1d=None):\n if nlambfit is None:\n nlambfit = nxi\n if nphifit is None:\n nphifit = nxj\n return _comp_optics._calc_spect1d_from_data2d(\n data, lamb, phi,\n nlambfit=nlambfit,\n nphifit=nphifit,\n spect1d=spect1d,\n mask=mask,\n vertsum1d=vertsum1d,\n )\n\n def plot_data_vs_lambphi(\n self,\n xi=None, xj=None, data=None, mask=None,\n det=None, dtheta=None, psi=None, n=None,\n nlambfit=None, nphifit=None,\n magaxis=None, npaxis=None,\n dlines=None, spect1d='mean',\n lambmin=None, lambmax=None,\n xjcut=None, dxj=None,\n plot=True, fs=None, tit=None, wintit=None,\n cmap=None, vmin=None, vmax=None,\n returnas=None,\n ):\n # Check / format inputs\n assert data is not None\n if returnas is None:\n returnas = 'spect'\n lreturn = ['ax', 'spect']\n if returnas not in lreturn:\n msg = (\"Arg returnas must be in {}\\n:\".format(lreturn)\n + \"\\t- 'spect': return a 1d vertically averaged spectrum\\n\"\n + \"\\t- 'ax' : return a list of axes instances\")\n raise Exception(msg)\n\n xi, xj, (xii, xjj) = _comp_optics._checkformat_xixj(xi, xj)\n nxi = xi.size if xi is not None else np.unique(xii).size\n nxj = xj.size if xj is not None else np.unique(xjj).size\n\n # Compute lamb / phi\n bragg, phi, lamb = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n xi=xii, xj=xjj, det=det,\n dtheta=dtheta, psi=psi,\n use_non_parallelism=use_non_parallelism,\n n=n,\n grid=True,\n return_lamb=True,\n )\n\n # Compute lambfit / phifit and spectrum1d\n (spect1d, lambfit, phifit,\n vertsum1d, phiminmax) = self._calc_spect1d_from_data2d(\n data, lamb, phi,\n nlambfit=nlambfit, nphifit=nphifit, nxi=nxi, nxj=nxj,\n spect1d=spect1d, mask=mask, vertsum1d=True\n )\n\n # Get phiref from mag axis\n lambax, phiax = None, None\n if magaxis is not None:\n if npaxis is None:\n npaxis = 1000\n thetacryst = np.arctan2(self._dgeom['summit'][1],\n self._dgeom['summit'][0])\n thetaax = thetacryst + np.pi/2*np.linspace(-1, 1, npaxis)\n pts = np.array([magaxis[0]*np.cos(thetaax),\n magaxis[0]*np.sin(thetaax),\n np.full((npaxis,), magaxis[1])])\n braggax, phiax = self.calc_braggphi_from_pts(pts)\n lambax = self.get_lamb_from_bragg(braggax)\n phiax = np.arctan2(np.sin(phiax-np.pi), np.cos(phiax-np.pi))\n ind = ((lambax >= lambfit[0]) & (lambax <= lambfit[-1])\n & (phiax >= phifit[0]) & (phiax <= phifit[-1]))\n lambax, phiax = lambax[ind], phiax[ind]\n ind = np.argsort(lambax)\n lambax, phiax = lambax[ind], phiax[ind]\n\n # Get lamb / phi for xj\n lambcut, phicut, spectcut = None, None, None\n if xjcut is not None:\n if dxj is None:\n dxj = 0.002\n xjcut = np.sort(np.atleast_1d(xjcut).ravel())\n xicutf = np.tile(xi, (xjcut.size, 1))\n xjcutf = np.repeat(xjcut[:, None], nxi, axis=1)\n (\n braggcut, phicut, lambcut,\n ) = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n xi=xicutf, xj=xjcutf, det=det,\n dtheta=0, psi=0,\n use_non_parallelism=use_non_parallelism,\n n=1,\n grid=True,\n return_lamb=True,\n )\n indxj = [(np.abs(xj-xjc) <= dxj).nonzero()[0] for xjc in xjcut]\n spectcut = np.array([np.nanmean(data[ixj, :], axis=0)\n for ixj in indxj])\n\n # plot\n ax = None\n if plot:\n ax = _plot_optics.CrystalBragg_plot_data_vs_lambphi(\n xi, xj, bragg, lamb, phi, data,\n lambfit=lambfit, phifit=phifit, spect1d=spect1d,\n vertsum1d=vertsum1d, lambax=lambax, phiax=phiax,\n lambmin=lambmin, lambmax=lambmax, phiminmax=phiminmax,\n xjcut=xjcut, lambcut=lambcut, phicut=phicut, spectcut=spectcut,\n cmap=cmap, vmin=vmin, vmax=vmax, dlines=dlines,\n tit=tit, wintit=wintit, fs=fs)\n if returnas == 'spect':\n return spect1d, lambfit\n elif returnas == 'ax':\n return ax\n\n def get_plasmadomain_at_lamb(\n self,\n config=None,\n struct=None,\n domain=None,\n res=None,\n det=None,\n xixj_lim=None,\n strict=None,\n bragg=None,\n lamb=None,\n # for available lamb determination\n ndtheta=None,\n nlamb=None,\n n=None,\n use_non_parallelism=None,\n # plotting\n plot=None,\n dax=None,\n plot_as=None,\n lcolor=None,\n return_dax=None,\n ):\n \"\"\" Return pts in the plasma domain and a mask\n\n The mask is True only for points for which the desired wavelength is\n accesible from the crystal (and from the detector if strict=True and\n det is provided)\n\n More than one value of lamb can be provided (nlamb >= 1)\n\n pts is returned as a (3, npts) array\n lambok is returned as a (nlamb, npts) array\n\n \"\"\"\n\n # ------------\n # check inputs\n\n struct = _check_optics._check_config_get_Ves(\n config=config, struct=struct,\n )\n\n bragg = self._checkformat_bragglamb(bragg=bragg, lamb=lamb, n=n)\n lamb = self.get_lamb_from_bragg(bragg=bragg, n=n)\n\n # To be refined if xjlim is narrow\n if ndtheta is None:\n ndtheta = 5\n # To be refined if xilim is narrow\n if nlamb is None:\n nlamb = 11\n if strict is None:\n strict = True\n\n if plot is None:\n plot = True\n if return_dax is None:\n return_dax = plot is True\n\n # -------------\n # sample volume\n\n (\n pts, dV, ind, (resR, resZ, resPhi),\n ) = config.dStruct['dObj']['Ves'][struct].get_sampleV(\n res=res,\n domain=domain,\n returnas='(R, Z, Phi)',\n )\n\n # ------------------------------\n # check access from crystal only\n\n ptsXYZ = np.array([\n pts[0, :]*np.cos(pts[2, :]),\n pts[0, :]*np.sin(pts[2, :]),\n pts[1, :],\n ])\n\n lamb_access = self.get_lamb_avail_from_pts(\n pts=ptsXYZ,\n nlamb=2,\n use_non_parallelism=use_non_parallelism,\n return_phidtheta=False,\n return_xixj=False,\n strict=False,\n )\n\n lambok = np.zeros((lamb.size, pts.shape[1]), dtype=bool)\n for ii, ll in enumerate(lamb):\n lambok[ii, :] = (\n (lamb_access[:, 0] <= ll) & (ll <= lamb_access[:, 1])\n )\n\n # ---------------\n # refactor pts and lambok\n\n indok = np.any(lambok, axis=0)\n pts = pts[:, indok]\n ptsXYZ = ptsXYZ[:, indok]\n lambok = lambok[:, indok]\n\n # ---------------\n # check strict\n if strict is True:\n\n # det vs detbis if xixj_lim\n detbis = dict(det)\n if xixj_lim is not None:\n detbis['outline'] = np.array([\n np.r_[\n xixj_lim[0][0],\n xixj_lim[0][1]*np.r_[1, 1],\n xixj_lim[0][0],\n ],\n np.r_[\n xixj_lim[1][0]*np.r_[1, 1],\n xixj_lim[1][1]*np.r_[1, 1],\n ],\n ])\n detbis['outline'] = np.concatenate(\n (detbis['outline'], detbis['outline'][:, 0:1]),\n axis=1,\n )\n\n # intersection with detbis\n for kk, ll in enumerate(lamb):\n lambi = _comp_optics._get_lamb_avail_from_pts_phidtheta_xixj(\n cryst=self,\n lamb=np.full((lambok[kk, :].sum(), 1), ll),\n n=n,\n ndtheta=ndtheta,\n pts=ptsXYZ[:, lambok[kk, :]],\n use_non_parallelism=use_non_parallelism,\n return_phidtheta=False,\n return_xixj=False,\n strict=strict,\n det=detbis,\n )\n lambok[kk, lambok[kk, :]] = ~np.isnan(lambi[:, 0])\n\n # -------\n # return\n\n if plot:\n dax = _plot_optics.CrystalBragg_plot_plasma_domain_at_lamb(\n cryst=self,\n det=det,\n xixj_lim=xixj_lim,\n config=config,\n lamb=lamb,\n pts=pts,\n reseff=[resR, resZ, resPhi],\n lambok=lambok,\n dax=dax,\n plot_as=plot_as,\n lcolor=lcolor,\n )\n\n # ---------------\n # return\n\n if return_dax is True:\n return pts, lambok, dax\n else:\n return pts, lambok\n\n def calc_signal_from_emissivity(\n self,\n emis=None,\n config=None,\n struct=None,\n domain=None,\n res=None,\n det=None,\n xixj_lim=None,\n strict=None,\n bragg=None,\n lamb=None,\n binning=None,\n # for available lamb determination\n ndtheta=None,\n nlamb=None,\n n=None,\n use_non_parallelism=None,\n # plotting\n plot=None,\n vmin=None,\n vmax=None,\n vmin_bin=None,\n vmax_bin=None,\n cmap=None,\n dax=None,\n fs=None,\n dmargin=None,\n tit=None,\n return_dax=None,\n ):\n \"\"\" Return pts in the plasma domain and a mask\n\n The mask is True only for points for which the desired wavelength is\n accesible from the crystal (and from the detector if strict=True and\n det is provided)\n\n More than one value of lamb can be provided (nlamb >= 1)\n\n pts is returned as a (3, npts) array\n lambok is returned as a (nlamb, npts) array\n\n \"\"\"\n\n # ------------\n # check inputs\n\n (\n struct, lamb, binning,\n ) = _check_optics._check_calc_signal_from_emissivity(\n emis=emis, config=config, struct=struct,\n lamb=lamb, det=det, binning=binning,\n )\n\n bragg = self._checkformat_bragglamb(bragg=bragg, lamb=lamb, n=n)\n lamb = self.get_lamb_from_bragg(bragg=bragg, n=n)\n\n # To be refined if xjlim is narrow\n if ndtheta is None:\n ndtheta = 5\n # To be refined if xilim is narrow\n if nlamb is None:\n nlamb = 11\n if strict is None:\n strict = True\n\n if plot is None:\n plot = True\n if return_dax is None:\n return_dax = plot is True\n\n # -------------\n # sample volume\n\n (\n pts, dV, ind, (resR, resZ, resPhi),\n ) = config.dStruct['dObj']['Ves'][struct].get_sampleV(\n res=res,\n domain=domain,\n returnas='(R, Z, Phi)',\n )\n\n # ------------------------------\n # check access from crystal only\n\n ptsXYZ = np.array([\n pts[0, :]*np.cos(pts[2, :]),\n pts[0, :]*np.sin(pts[2, :]),\n pts[1, :],\n ])\n\n lamb_access = self.get_lamb_avail_from_pts(\n pts=ptsXYZ,\n nlamb=2,\n use_non_parallelism=use_non_parallelism,\n return_phidtheta=False,\n return_xixj=False,\n strict=False,\n )\n\n lambok = np.zeros((lamb.size, pts.shape[1]), dtype=bool)\n for ii, ll in enumerate(lamb):\n lambok[ii, :] = (\n (lamb_access[:, 0] <= ll) & (ll <= lamb_access[:, 1])\n )\n\n # ---------------\n # refactor pts and lambok\n\n indok = np.any(lambok, axis=0)\n pts = pts[:, indok]\n ptsXYZ = ptsXYZ[:, indok]\n lambok = lambok[:, indok]\n\n # ---------------\n # check strict\n\n # det vs detbis if xixj_lim\n detbis = dict(det)\n if xixj_lim is not None:\n detbis['outline'] = np.array([\n np.r_[\n xixj_lim[0][0],\n xixj_lim[0][1]*np.r_[1, 1],\n xixj_lim[0][0],\n ],\n np.r_[\n xixj_lim[1][0]*np.r_[1, 1],\n xixj_lim[1][1]*np.r_[1, 1],\n ],\n ])\n detbis['outline'] = np.concatenate(\n (detbis['outline'], detbis['outline'][:, 0:1]),\n axis=1,\n )\n\n # intersection with detbis\n shape = tuple(np.r_[pts.shape[1], lamb.size, ndtheta, 2])\n xi = np.full(shape, np.nan)\n xj = np.full(shape, np.nan)\n val = np.full(shape, np.nan)\n for kk, ll in enumerate(lamb):\n (\n lambi, xii, xji,\n ) = _comp_optics._get_lamb_avail_from_pts_phidtheta_xixj(\n cryst=self,\n lamb=np.full((lambok[kk, :].sum(), 1), ll),\n n=n,\n ndtheta=ndtheta,\n pts=ptsXYZ[:, lambok[kk, :]],\n use_non_parallelism=use_non_parallelism,\n return_phidtheta=False,\n return_xixj=True,\n strict=True,\n det=detbis,\n )\n\n iok = ~np.isnan(lambi[:, 0])\n iokf = lambok[kk, :].nonzero()[0][iok]\n lambok[kk, lambok[kk, :]] = iok\n xi[iokf, kk, :, :] = xii[iok, 0, :, :]\n xj[iokf, kk, :, :] = xji[iok, 0, :, :]\n val[iokf, kk, :, :] = emis(\n r=pts[0, iokf],\n z=pts[1, iokf],\n phi=pts[2, iokf],\n lamb=lamb[kk:kk+1],\n t=None,\n )[:, 0, None, None]\n\n # -------\n # Optional binning\n\n binned = None\n if binning is not False:\n iok = np.isfinite(val)\n binned = scpstats.binned_statistic_2d(\n xi[iok].ravel(),\n xj[iok].ravel(),\n val[iok].ravel(),\n statistic='mean',\n bins=binning,\n expand_binnumbers=False,\n )[0]\n\n # -------\n # return\n\n if plot:\n dax = _plot_optics.CrystalBragg_plot_signal_from_emissivity(\n cryst=self,\n det=det,\n xixj_lim=xixj_lim,\n config=config,\n lamb=lamb,\n pts=pts,\n reseff=[resR, resZ, resPhi],\n xi=xi,\n xj=xj,\n val=val,\n lambok=lambok,\n binning=binning,\n binned=binned,\n # plotting\n vmin=vmin,\n vmax=vmax,\n vmin_bin=vmin_bin,\n vmax_bin=vmax_bin,\n cmap=cmap,\n dax=dax,\n fs=fs,\n dmargin=dmargin,\n tit=tit,\n )\n\n # ---------------\n # return\n\n if return_dax is True:\n return pts, val, xi, xj, binned, dax\n else:\n return pts, val, xi, xj, binned\n\n @staticmethod\n def fit1d_dinput(\n dlines=None, dconstraints=None, dprepare=None,\n data=None, lamb=None,\n mask=None, domain=None, pos=None, subset=None,\n same_spectrum=None, same_spectrum_dlamb=None,\n focus=None, valid_fraction=None, valid_nsigma=None,\n focus_half_width=None, valid_return_fract=None,\n ):\n \"\"\" Return a formatted dict of lines and constraints\n\n To be fed to _fit12d.multigausfit1d_from_dlines()\n Provides a user-friendly way of defining constraints\n \"\"\"\n\n import tofu.spectro._fit12d as _fit12d\n return _fit12d.fit1d_dinput(\n dlines=dlines, dconstraints=dconstraints, dprepare=dprepare,\n data=data, lamb=lamb,\n mask=mask, domain=domain, pos=pos, subset=subset,\n same_spectrum=same_spectrum,\n same_spectrum_dlamb=same_spectrum_dlamb,\n focus=focus, valid_fraction=valid_fraction,\n valid_nsigma=valid_nsigma, focus_half_width=focus_half_width,\n valid_return_fract=valid_return_fract)\n\n def fit1d(\n self,\n # Input data kwdargs\n data=None, lamb=None,\n dinput=None, dprepare=None, dlines=None, dconstraints=None,\n mask=None, domain=None, subset=None, pos=None,\n same_spectrum=None, same_spectrum_dlamb=None,\n focus=None, valid_fraction=None, valid_nsigma=None,\n focus_half_width=None,\n # Optimization kwdargs\n dx0=None, dscales=None, x0_scale=None, bounds_scale=None,\n method=None, tr_solver=None, tr_options=None, max_nfev=None,\n xtol=None, ftol=None, gtol=None,\n loss=None, verbose=None, chain=None, jac=None, showonly=None,\n # Results extraction kwdargs\n amp=None, coefs=None, ratio=None,\n Ti=None, width=None, vi=None, shift=None,\n pts_lamb_total=None, pts_lamb_detail=None,\n # Saving and plotting kwdargs\n save=None, name=None, path=None,\n plot=None, fs=None, dmargin=None,\n tit=None, wintit=None, returnas=None,\n ):\n\n # ----------------------\n # Get dinput for 1d fitting from dlines, dconstraints, dprepare...\n if dinput is None:\n dinput = self.fit1d_dinput(\n dlines=dlines, dconstraints=dconstraints, dprepare=dprepare,\n data=data, lamb=lamb,\n mask=mask, domain=domain, pos=pos, subset=subset,\n focus=focus, valid_fraction=valid_fraction,\n valid_nsigma=valid_nsigma, focus_half_width=focus_half_width,\n same_spectrum=same_spectrum,\n same_spectrum_dlamb=same_spectrum_dlamb)\n\n # ----------------------\n # return\n import tofu.spectro._fit12d as _fit12d\n return _fit12d.fit1d(\n # Input data kwdargs\n data=data, lamb=lamb,\n dinput=dinput, dprepare=dprepare,\n dlines=dlines, dconstraints=dconstraints,\n mask=mask, domain=domain, subset=subset, pos=pos,\n # Optimization kwdargs\n method=method, tr_solver=tr_solver, tr_options=tr_options,\n xtol=xtol, ftol=ftol, gtol=gtol,\n max_nfev=max_nfev, loss=loss, chain=chain,\n dx0=dx0, x0_scale=x0_scale, bounds_scale=bounds_scale,\n jac=jac, verbose=verbose,\n save=save, name=name, path=path,\n amp=amp, coefs=coefs, ratio=ratio,\n Ti=Ti, width=width, vi=vi, shift=shift,\n pts_lamb_total=pts_lamb_total,\n pts_lamb_detail=pts_lamb_detail,\n plot=plot, fs=fs, wintit=wintit, tit=tit)\n\n @staticmethod\n def fit1d_extract(\n dfit1d=None,\n amp=None, coefs=None, ratio=None,\n Ti=None, width=None,\n vi=None, shift=None,\n pts_lamb_total=None, pts_lamb_detail=None,\n ):\n import tofu.spectro._fit12d as _fit12d\n return _fit12d.fit1d_extract(\n dfit1d=dfit,\n amp=amp, coefs=coefs, ratio=ratio,\n Ti=Ti, width=width,\n vi=vi, shift=shift,\n pts_lamb_total=pts_lamb_total, pts_lamb_detail=pts_lamb_detail)\n\n def fit1d_from2d(self):\n \"\"\" Useful for optimizing detector or crystal position\n\n Given a set of 2d images on a detector\n Transform the 2d (xi, xj) image into (lamb, phi)\n Slice nphi 1d spectra\n Fit them using a dict of reference lines (dlines)\n Optionally provide constraints for the fitting\n Return the vertical profiles of the wavelength shitf of each line\n To be used as input for an cost function and optimization\n\n 1d fitting is used instead of 2d because:\n - faster (for optimization)\n - does not require a choice of nbsplines\n - easier to understand and decide for user\n\n \"\"\"\n # Check / format inputs\n if lphi is None:\n msg = (\"Arg lphi must be provided !\")\n raise Exception(msg)\n\n # ----------------------\n # Prepare input data\n # (geometrical transform, domain, binning, subset, noise...)\n if dprepare is None:\n dprepare = self.fit2d_prepare(\n data=data, xi=xi, xj=xj, n=n,\n det=det, dtheta=dtheta, psi=psi,\n mask=mask, domain=domain,\n pos=pos, binning=binning,\n nbsplines=False, subset=False,\n lphi=lphi, lphi_tol=lphi_tol)\n\n # ----------------------\n # Get dinput for 2d fitting from dlines, and dconstraints\n if dinput is None:\n dinput = self.fit2d_dinput(\n dlines=dlines, dconstraints=dconstraints,\n deg=deg, knots=knots, nbsplines=nbsplines,\n domain=dprepare['domain'],\n dataphi1d=dprepare['dataphi1d'], phi1d=dprepare['phi1d'])\n\n # ----------------------\n # fit\n out = self.fit1d(\n xi=None, xj=None, data=None, mask=None,\n det=None, dtheta=None, psi=None, n=None,\n nlambfit=None, nphifit=None,\n lambmin=None, lambmax=None,\n dlines=None, spect1d=None,\n dconstraints=None, dx0=None,\n same_spectrum=None, dlamb=None,\n double=None,\n dscales=None, x0_scale=None, bounds_scale=None,\n method=None, max_nfev=None,\n xtol=None, ftol=None, gtol=None,\n loss=None, verbose=0, chain=None,\n jac=None, showonly=None,\n plot=None, fs=None, dmargin=None,\n tit=None, wintit=None, returnas=None,\n )\n pass\n\n def fit2d_dinput(\n self, dlines=None, dconstraints=None, dprepare=None,\n data=None, xi=None, xj=None, n=None,\n det=None, dtheta=None, psi=None,\n mask=None, domain=None, pos=None, binning=None, subset=None,\n # lphi=None, lphi_tol=None,\n deg=None, knots=None, nbsplines=None,\n focus=None, valid_fraction=None, valid_nsigma=None,\n focus_half_width=None, valid_return_fract=None,\n ):\n \"\"\" Return a formatted dict of lines and constraints\n\n To be fed to _fit12d.multigausfit1d_from_dlines()\n Provides a user-friendly way of defining constraints\n \"\"\"\n\n import tofu.spectro._fit12d as _fit12d\n if dprepare is None:\n # ----------------------\n # Geometrical transform\n xi, xj, (xii, xjj) = _comp_optics._checkformat_xixj(xi, xj)\n nxi = xi.size if xi is not None else np.unique(xii).size\n nxj = xj.size if xj is not None else np.unique(xjj).size\n\n # Compute lamb / phi\n bragg, phi, lamb = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n xi=xii, xj=xjj, det=det,\n dtheta=dtheta, psi=psi,\n use_non_parallelism=use_non_parallelism,\n n=n,\n grid=True,\n return_lamb=True,\n )\n\n # ----------------------\n # Prepare input data (domain, binning, subset, noise...)\n dprepare = _fit12d.multigausfit2d_from_dlines_prepare(\n data, lamb, phi,\n mask=mask, domain=domain,\n pos=pos, binning=binning,\n nbsplines=nbsplines, subset=subset,\n nxi=nxi, nxj=nxj,\n ) # , lphi=lphi, lphi_tol=lphi_tol)\n return _fit12d.fit2d_dinput(\n dlines=dlines, dconstraints=dconstraints, dprepare=dprepare,\n deg=deg, knots=knots, nbsplines=nbsplines,\n focus=focus, valid_fraction=valid_fraction,\n valid_nsigma=valid_nsigma, focus_half_width=focus_half_width,\n valid_return_fract=valid_return_fract)\n\n def fit2d(\n self,\n # Input data kwdargs\n data=None, xi=None, xj=None,\n det=None, dtheta=None, psi=None, n=None,\n dinput=None, dprepare=None, dlines=None, dconstraints=None,\n mask=None, domain=None, subset=None, pos=None, binning=None,\n focus=None, valid_fraction=None, valid_nsigma=None,\n focus_half_width=None,\n deg=None, knots=None, nbsplines=None,\n # Optimization kwdargs\n dx0=None, dscales=None, x0_scale=None, bounds_scale=None,\n method=None, tr_solver=None, tr_options=None, max_nfev=None,\n xtol=None, ftol=None, gtol=None,\n loss=None, verbose=None, chain=None, jac=None, showonly=None,\n predeclare=None, debug=None,\n # Results extraction kwdargs\n amp=None, coefs=None, ratio=None,\n Ti=None, width=None, vi=None, shift=None,\n pts_lamb_total=None, pts_lamb_detail=None,\n # Saving and plotting kwdargs\n save=None, name=None, path=None,\n plot=None, fs=None, dmargin=None,\n tit=None, wintit=None, returnas=None,\n ):\n\n # npts=None, dax=None,\n # spect1d=None, nlambfit=None,\n # plotmode=None, angunits=None, indspect=None,\n # cmap=None, vmin=None, vmax=None):\n \"\"\" Perform 2d fitting of a 2d spectrometre image\n\n Fit the spectrum by a sum of gaussians\n Modulate each gaussian parameters by bsplines in the spatial direction\n\n data must be provided in shape (nt, nxi, nxj), where:\n - nt is the number of time steps\n - nxi is the nb. of pixels in the horizontal / spectral direction\n - nxj is the nb. of pixels in the vertical / spacial direction\n\n \"\"\"\n\n # ----------------------\n # Geometrical transform in dprepare\n if dinput is None:\n dinput = self.fit2d_dinput(\n dlines=dlines, dconstraints=dconstraints, dprepare=dprepare,\n data=data, xi=xi, xj=xj, n=n,\n det=det, dtheta=dtheta, psi=psi,\n mask=mask, domain=domain,\n pos=pos, binning=binning, subset=subset,\n deg=deg, knots=knots, nbsplines=nbsplines,\n focus=focus, valid_fraction=valid_fraction,\n valid_nsigma=valid_nsigma, focus_half_width=focus_half_width)\n\n # ----------------------\n # return\n import tofu.spectro._fit12d as _fit12d\n return _fit12d.fit2d(\n dinput=dinput, dprepare=dprepare,\n dlines=dlines, dconstraints=dconstraints,\n lamb=lamb, phi=phi, data=data, mask=mask,\n nxi=dinput['dprepare']['nxi'], nxj=dinput['dprepare']['nxj'],\n domain=domain, pos=pos, binning=binning, subset=subset,\n deg=deg, knots=knots, nbsplines=nbsplines,\n method=method, tr_solver=tr_solver, tr_options=tr_options,\n xtol=xtol, ftol=ftol, gtol=gtol,\n max_nfev=max_nfev, loss=loss, chain=chain,\n dx0=dx0, x0_scale=x0_scale, bounds_scale=bounds_scale,\n jac=jac, verbose=verbose,\n save=save, name=name, path=path,\n plot=plot)\n\n @staticmethod\n def fit2d_extract(dfit2d=None,\n amp=None, Ti=None, vi=None,\n pts_phi=None, npts_phi=None,\n pts_lamb_phi_total=None,\n pts_lamb_phi_detail=None):\n import tofu.spectro._fit12d as _fit12d\n return _fit12d.fit2d_extract_data(\n dfit2d=dfit2d,\n amp=amp, Ti=Ti, vi=vi,\n pts_phi=pts_phi, npts_phi=npts_phi,\n pts_lamb_phi_total=pts_lamb_phi_total,\n pts_lamb_phi_detail=pts_lamb_phi_detail)\n\n def fit2d_plot(self, dfit2d=None, ratio=None,\n dax=None, plotmode=None, angunits=None,\n cmap=None, vmin=None, vmax=None,\n dmargin=None, tit=None, wintit=None, fs=None):\n dout = self.fit2d_extract(\n dfit2d,\n amp=amp, Ti=Ti, vi=vi,\n pts_lamb_phi_total=pts_lamb_phi_total,\n pts_lamb_phi_detail=pts_lamb_phi_detail)\n return _plot_optics.CrystalBragg_plot_data_fit2d(\n dfit2d=dfit2d, dout=dout, ratio=ratio,\n dax=dax, plotmode=plotmode, angunits=angunits,\n cmap=cmap, vmin=vmin, vmax=vmax,\n dmargin=dmargin, tit=tit, wintit=wintit, fs=fs)\n\n def noise_analysis(\n self, data=None, xi=None, xj=None, n=None,\n det=None, dtheta=None, psi=None,\n mask=None, valid_fraction=None, nxerrbin=None,\n margin=None, domain=None, nlamb=None,\n deg=None, knots=None, nbsplines=None,\n loss=None, max_nfev=None,\n xtol=None, ftol=None, gtol=None,\n method=None, tr_solver=None, tr_options=None,\n verbose=None, plot=None,\n ms=None, dcolor=None,\n dax=None, fs=None, dmargin=None,\n wintit=None, tit=None, sublab=None,\n save_fig=None, name_fig=None, path_fig=None,\n fmt=None, return_dax=None,\n ):\n\n # ----------------------\n # Geometrical transform\n bragg, phi, lamb = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n xi=xi, xj=xj, det=det,\n dtheta=dtheta, psi=psi,\n use_non_parallelism=use_non_parallelism,\n n=n,\n grid=True,\n return_lamb=True,\n )\n\n import tofu.spectro._fit12d as _fit12d\n return _fit12d.noise_analysis_2d(\n data, lamb, phi,\n mask=mask, valid_fraction=valid_fraction,\n margin=margin, nxerrbin=nxerrbin,\n nlamb=nlamb, deg=deg, knots=knots, nbsplines=nbsplines,\n loss=loss, max_nfev=max_nfev,\n xtol=xtol, ftol=ftol, gtol=gtol,\n method=method, tr_solver=tr_solver, tr_options=tr_options,\n verbose=verbose, plot=plot,\n ms=ms, dcolor=dcolor,\n dax=dax, fs=fs, dmargin=dmargin,\n wintit=wintit, tit=tit, sublab=sublab,\n save_fig=save_fig, name_fig=name_fig, path_fig=path_fig,\n fmt=fmt, return_dax=return_dax)\n\n @staticmethod\n def noise_analysis_plot(\n dnoise=None, margin=None, valid_fraction=None,\n ms=None, dcolor=None,\n dax=None, fs=None, dmargin=None,\n wintit=None, tit=None, sublab=None,\n save=None, name=None, path=None, fmt=None,\n ):\n import tofu.spectro._plot as _plot_spectro\n return _plot_spectro.plot_noise_analysis(\n dnoise=dnoise, margin=margin, valid_fraction=valid_fraction,\n ms=ms, dcolor=dcolor,\n dax=dax, fs=fs, dmargin=dmargin,\n wintit=wintit, tit=tit, sublab=sublab,\n save=save, name=name, path=path, fmt=fmt)\n\n def noise_analysis_scannbs(\n self, data=None, xi=None, xj=None, n=None,\n det=None, dtheta=None, psi=None,\n mask=None, nxerrbin=None,\n domain=None, nlamb=None,\n deg=None, knots=None, nbsplines=None, lnbsplines=None,\n loss=None, max_nfev=None,\n xtol=None, ftol=None, gtol=None,\n method=None, tr_solver=None, tr_options=None,\n verbose=None, plot=None,\n ms=None, dax=None, fs=None, dmargin=None,\n wintit=None, tit=None, sublab=None,\n save_fig=None, name_fig=None, path_fig=None,\n fmt=None, return_dax=None,\n ):\n\n # ----------------------\n # Geometrical transform\n bragg, phi, lamb = self.get_lambbraggphi_from_ptsxixj_dthetapsi(\n xi=xi, xj=xj, det=det,\n dtheta=0, psi=0,\n use_non_parallelism=use_non_parallelism,\n n=n,\n grid=True,\n return_lamb=True,\n )\n\n import tofu.spectro._fit12d as _fit12d\n return _fit12d.noise_analysis_2d_scannbs(\n data, lamb, phi,\n mask=mask, nxerrbin=nxerrbin, nlamb=nlamb,\n deg=deg, knots=knots, nbsplines=nbsplines, lnbsplines=lnbsplines,\n loss=loss, max_nfev=max_nfev,\n xtol=xtol, ftol=ftol, gtol=gtol,\n method=method, tr_solver=tr_solver, tr_options=tr_options,\n verbose=verbose, plot=plot,\n ms=ms, dax=dax, fs=fs, dmargin=dmargin,\n wintit=wintit, tit=tit, sublab=sublab,\n save_fig=save_fig, name_fig=name_fig, path_fig=path_fig,\n fmt=fmt, return_dax=return_dax)\n\n @staticmethod\n def noise_analysis_scannbs_plot(\n dnoise_scan=None, ms=None,\n dax=None, fs=None, dmargin=None,\n wintit=None, tit=None, sublab=None,\n save=None, name=None, path=None, fmt=None,\n ):\n import tofu.spectro._plot as _plot_spectro\n return _plot_spectro.plot_noise_analysis_scannbs(\n dnoise=dnoise_scan, ms=ms,\n dax=dax, fs=fs, dmargin=dmargin,\n wintit=wintit, tit=tit, sublab=sublab,\n save=save, name=name, path=path, fmt=fmt)\n"
] | [
[
"numpy.arccos",
"numpy.tile",
"numpy.min",
"numpy.mean",
"numpy.nanmean",
"numpy.cos",
"numpy.concatenate",
"numpy.full",
"numpy.sin",
"numpy.max",
"numpy.linalg.norm",
"matplotlib.colors.to_rgba",
"numpy.nanmin",
"numpy.arange",
"numpy.hypot",
"numpy.sqrt",
"numpy.isfinite",
"numpy.nanmax",
"numpy.cross",
"numpy.vstack",
"numpy.array",
"scipy.interpolate.interp1d",
"numpy.zeros",
"numpy.round",
"matplotlib.pyplot.figure",
"numpy.allclose",
"numpy.arctan2",
"numpy.argsort",
"numpy.nanargmin",
"numpy.isnan",
"numpy.sum",
"matplotlib.pyplot.plot",
"numpy.any",
"numpy.atleast_1d",
"numpy.abs",
"scipy.interpolate.interp2d",
"numpy.repeat",
"numpy.linspace",
"numpy.meshgrid",
"numpy.unique"
]
] |
srihari-nagaraj/anuvaad | [
"b09b01a033a033e97db6e404c088e0e6332053e4",
"b09b01a033a033e97db6e404c088e0e6332053e4"
] | [
"anuvaad-etl/anuvaad-extractor/document-processor/evaluator/evaluator_string/src/notebooks/tesseract_ocr_evaluation_local.py",
"anuvaad-etl/anuvaad-extractor/document-processor/block-segmenter/src/utilities/yolov5/datasets.py"
] | [
"import glob\nimport uuid\nimport json\nimport requests\nimport copy,time\nimport os\nimport cv2\nimport numpy as np\nfrom time import sleep\nimport pandas as pd\nimport logging\nfrom collections import Counter\nimport pytesseract\nfrom pytesseract import Output\n#from pytesseract import pytesseract\nfrom difflib import SequenceMatcher\nfrom io import StringIO\nfrom dynamic_adjustment import coord_adjustment\nimport ast\nfrom leven import levenshtein\nfrom horizontal_merging import horzontal_merging\n\nocr_level = \"LINE\"\ntext_processing = True\nREJECT_FILTER = 2\n#crop_factor= 5\n#crop_factor_y= 4\ncrop_factor= 5\ncrop_factor_y= 0\ncrop_save = True\ndigitization = True\nvis_thresh=0.90\nLANG_MAPPING = {\n \"en\" : [\"Latin\",\"eng\"],\n \"kn\" : ['Kannada',\"kan\"],\n \"gu\": [\"guj\"],\n \"or\": [\"ori\"],\n \"hi\" : [\"Devanagari\",\"hin\",\"eng\"],\n \"bn\" : [\"Bengali\",\"ben\"],\n \"mr\": [\"Devanagari\",\"hin\",\"eng\"],\n \"ta\": ['Tamil',\"tam\"],\n \"te\" : [\"Telugu\",\"tel\"],\n \"ml\" :[\"Malayalam\"],\n \"ma\" :[\"Marathi\"]\n}\n\n\n#path = '/home/ubuntu/tesseract_evaluation/data/'\n#output_path = '/home/ubuntu/tesseract_evaluation/result/'\n#output_path_boxes= '/home/ubuntu/tesseract_evaluation/test_word_boxes/'\n#base_path = '/home/ubuntu/tesseract_evaluation/test_word_boxes/'\npath = '/home/naresh/Tarento/testing_document_processor/test_pipeline/data/'\noutput_path = '/home/naresh/Tarento/testing_document_processor/test_pipeline/result/'\noutput_path_boxes= '/home/naresh/Tarento/testing_document_processor/test_word_boxes/'\nbase_path= '/home/naresh/Tarento/testing_document_processor/test_word_boxes/'\n\n\npsms = [6,7,8,9,10,11]\ntoken = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6ImRoaXJhai5kYWdhQHRhcmVudG8uY29tIiwicGFzc3dvcmQiOiJiJyQyYiQxMiRuTXdNcHpCVlBXVVUvSlVLWXBKYWkuQUd2SUNJalJVcUdIbnBPenRzai5VRU55emlSZmk1TyciLCJleHAiOjE2MTk3Njg2NjN9.14IL5_kw83F5gxjUMSw6kCDLYQhjAg306AwJj0DsxWc'\n\n\nword_url = \"https://auth.anuvaad.org/anuvaad-etl/wf-manager/v1/workflow/async/initiate\"\ngoogle_url = \"https://auth.anuvaad.org/anuvaad-etl/wf-manager/v1/workflow/async/initiate\"\nlayout_url = \"https://auth.anuvaad.org/anuvaad-etl/wf-manager/v1/workflow/async/initiate\"\nsegmenter_url = \"https://auth.anuvaad.org/anuvaad-etl/wf-manager/v1/workflow/async/initiate\"\nbs_url =\"https://auth.anuvaad.org/anuvaad-etl/wf-manager/v1/workflow/jobs/search/bulk\"\n\nevaluator_url = \"https://auth.anuvaad.org/anuvaad-etl/document-processor/evaluator/v0/process\"\n\n#evaluator_url = 'http://0.0.0.0:5001/anuvaad-etl/document-processor/evaluator/v0/process'\n\ndownload_url =\"https://auth.anuvaad.org/download/\"\nupload_url = 'https://auth.anuvaad.org/anuvaad-api/file-uploader/v0/upload-file'\n\n\nheaders = {\n 'auth-token' :token }\n\n\n\n\n\nclass Draw:\n \n def __init__(self,input_json,save_dir,regions,prefix='',color= (255,0,0),thickness=5): \n self.json = input_json\n self.save_dir = save_dir\n self.regions = regions\n self.prefix = prefix\n self.color = color\n self.thickness=thickness\n if self.prefix == 'seg':\n #print('drawing children')\n self.draw_region_children()\n else:\n self.draw_region__sub_children()\n \n def get_coords(self,page_index):\n return self.json['outputs'][0]['pages'][page_index][self.regions]\n \n def get_page_count(self):\n return(self.json['outputs'][0]['page_info'])\n \n def get_page(self,page_index):\n page_path = self.json['outputs'][0]['page_info'][page_index]\n page_path = page_path.split('upload')[1]#'/'.join(page_path.split('/')[1:])\n #print(page_path) \n return download_file(download_url,headers,page_path,f_type='image')\n\n def draw_region(self):\n font = cv2.FONT_HERSHEY_SIMPLEX \n for page_index in range(len(self.get_page_count())) :\n nparr = np.frombuffer(self.get_page(page_index), np.uint8)\n image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)\n for region in self.get_coords(page_index) :\n ground = region['boundingBox']['vertices']\n pts = []\n for pt in ground:\n pts.append([int(pt['x']) ,int(pt['y'])])\n cv2.polylines(image, [np.array(pts)],True, self.color, self.thickness)\n if 'class' not in region.keys():\n region['class'] = 'TEXT'\n cv2.putText(image, str(region['class']), (pts[0][0],pts[0][1]), font, \n 2, (0,125,255), 3, cv2.LINE_AA)\n \n image_path = os.path.join(self.save_dir , '{}_{}_{}.png'.format(self.regions,self.prefix,page_index)) \n cv2.imwrite(image_path , image)\n \n def draw_region_children(self):\n font = cv2.FONT_HERSHEY_SIMPLEX \n fontScale = 2\n thickness =3\n\n\n for page_index in range(len(self.get_page_count())) :\n nparr = np.frombuffer(self.get_page(page_index), np.uint8)\n image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)\n for region_index,region in enumerate(self.get_coords(page_index)) :\n try:\n ground = region['boundingBox']['vertices']\n pts = []\n for pt in ground:\n pts.append([int(pt['x']) ,int(pt['y'])])\n #print(pts)\n region_color = (0 ,0,125+ 130*(region_index/ len(self.get_coords(page_index))))\n cv2.polylines(image, [np.array(pts)],True, region_color, self.thickness)\n cv2.putText(image, str(region_index), (pts[0][0],pts[0][1]), font, \n fontScale, region_color, thickness, cv2.LINE_AA)\n for line_index, line in enumerate(region['children']):\n ground = line['boundingBox']['vertices']\n pts = []\n for pt in ground:\n pts.append([int(pt['x']) ,int(pt['y'])])\n\n line_color = (125 + 130*(region_index/ len(self.get_coords(page_index))) ,0,0)\n cv2.polylines(image, [np.array(pts)],True, line_color, self.thickness -2)\n cv2.putText(image, str(line_index), (pts[0][0],pts[0][1]), font, \n fontScale, line_color, thickness, cv2.LINE_AA)\n except Exception as e:\n print(str(e))\n print(region)\n \n image_path = os.path.join(self.save_dir , '{}_{}.png'.format(self.prefix,page_index))\n cv2.imwrite(image_path , image)\n def draw_region__sub_children(self): \n for page_index in range(len(self.get_page_count())) :\n nparr = np.frombuffer(self.get_page(page_index), np.uint8)\n image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)\n \n font = cv2.FONT_HERSHEY_SIMPLEX \n fontScale = 2\n\n # Blue color in BGR \n color = (0 ,255,0) \n\n # Line thickness of 2 px \n thickness = 3\n\n # Using cv2.putText() method \n \n for region_index,region in enumerate(self.get_coords(page_index)) :\n try:\n ground = region['boundingBox']['vertices']\n pts = []\n for pt in ground:\n pts.append([int(pt['x']) ,int(pt['y'])])\n #print(pts)\n region_color = (0,0,255)\n cv2.polylines(image, [np.array(pts)],True, region_color, self.thickness)\n for line_index, line in enumerate(region['regions']):\n ground = line['boundingBox']['vertices']\n pts = []\n for pt in ground:\n pts.append([int(pt['x'])-1 ,int(pt['y']) -1 ])\n\n line_color = (255,0,0)\n cv2.polylines(image, [np.array(pts)],True, line_color, self.thickness -2)\n \n cv2.putText(image, str(line_index), (pts[0][0],pts[0][1]), font, \n fontScale, (255,0,0), thickness, cv2.LINE_AA)\n for word_index, word in enumerate(line['regions']):\n ground = word['boundingBox']['vertices']\n pts = []\n for pt in ground:\n pts.append([int(pt['x']) -3,int(pt['y'])-3])\n\n word_color = (0,255,0)\n cv2.polylines(image, [np.array(pts)],True, word_color, self.thickness -2)\n\n cv2.putText(image, str(word_index), (pts[0][0],pts[0][1]), font, \n fontScale-1,(0,255,0), thickness, cv2.LINE_AA)\n except Exception as e:\n print(str(e))\n print(region)\n \n \n \n #print(self.prefix)\n image_path = os.path.join(self.save_dir , '{}_{}_{}.png'.format(self.prefix,self.regions,page_index))\n cv2.imwrite(image_path , image)\n\n\n\n\n\n# # google vision pipeline\n\n\ndef google_ocr_v15(url,headers,pdf_name):\n \n file = {\n \"files\": [\n {\n \"locale\": \"hi\",\n \"path\": pdf_name,\n \"type\": \"pdf\",\n \"config\":{\n \"OCR\": {\n \"option\": \"HIGH_ACCURACY\",\n \"language\": \"hi\",\n \"top_correction\":\"True\",\n \"craft_word\": \"True\",\n \"craft_line\": \"True\",\n }\n }}\n ],\n \"workflowCode\": \"WF_A_FCWDLDBSOD15GV\"\n }\n res = requests.post(url,json=file,headers=headers)\n return res.json()\n\n\n\n\n\ndef upload_file(pdf_file,headers,url):\n #url = 'https://auth.anuvaad.org/anuvaad-api/file-uploader/v0/upload-file'\n files = [\n ('file',(open(pdf_file,'rb')))] \n\n response = requests.post(url, headers=headers, files=files)\n \n return response.json()\n\n\n\n\n\ndef download_file(download_url,headers,outputfile,f_type='json'):\n download_url =download_url+str(outputfile)\n res = requests.get(download_url,headers=headers)\n if f_type == 'json':\n return res.json()\n else :\n return res.content\n\n\n\n\n\ndef save_json(path,res):\n with open(path, \"w\", encoding='utf8') as write_file:\n json.dump(res, write_file,ensure_ascii=False )\n\n\n\n\n\ndef bulk_search(job_id,bs_url,headers):\n bs_request = {\n \"jobIDs\": [job_id],\n \"taskDetails\":\"true\"\n }\n print(job_id)\n res = requests.post(bs_url,json=bs_request,headers=headers, timeout = 10000)\n print(res.json())\n \n \n while(1):\n \n in_progress = res.json()['jobs'][0]['status']\n \n if in_progress == 'COMPLETED':\n outputfile = res.json()['jobs'][0]['output'][0]['outputFile']\n print(in_progress)\n return outputfile\n break\n sleep(0.5)\n print(in_progress)\n res = requests.post(bs_url,json=bs_request,headers=headers, timeout = 10000)\n \n \n\n\n\n\n\ndef execute_module(module,url,input_file,module_code,pdf_dir,overwirte=True , draw=True):\n \n \n \n output_path = os.path.join(pdf_dir,'{}.json'.format(module_code))\n if os.path.exists(output_path) and not overwirte:\n print(' loading *****************{}'.format(module_code ))\n with open(output_path,'r') as wd_file :\n response = json.load(wd_file)\n \n wf_res = pdf_dir + '/{}_wf.json'.format(module_code)\n with open(wf_res,'r') as wd_file :\n json_file = json.load(wd_file) \n #json_file = upload_file(output_path,headers,upload_url)['data']\n else :\n if module_code in ['wd','gv']:\n res = upload_file(input_file,headers,upload_url)\n print('upload response **********', res)\n pdf_name = res['data']\n response = module(url,headers,pdf_name)\n \n else : \n response = module(url,headers,input_file)\n \n if 'eval' in module_code :\n json_file = response['outputFile']\n response = download_file(download_url,headers,json_file)\n save_json(output_path,response)\n return json_file,response\n \n \n print(' response *****************{} {}'.format(module_code ,response ))\n job_id = response['jobID']\n json_file = bulk_search(job_id,bs_url,headers)\n save_json(pdf_dir + '/{}_wf.json'.format(module_code),json_file) \n print('bulk search response **************',json_file )\n response = download_file(download_url,headers,json_file)\n save_json(output_path,response)\n if draw :\n if module_code in ['wd','gv']:\n Draw(response,pdf_dir,regions='lines',prefix=module_code)\n else :\n Draw(response,pdf_dir,regions='regions',prefix=module_code)\n \n return json_file,response\n \n\n\n\ndef evaluate__and_save_input(pdf_files,output_dir,headers,word_url,layout_url,download_url,upload_url,bs_url):\n word_responses = {}\n layout_responses = {}\n segmenter_responses = []\n for pdf in pdf_files:\n #try :\n pdf_name = pdf.split('/')[-1].split('.')[0]\n print(pdf , ' is being processed')\n pdf_output_dir = os.path.join(output_dir,pdf_name)\n os.system('mkdir -p \"{}\"'.format(pdf_output_dir))\n\n\n wd_json,_ = execute_module(google_ocr_v15,word_url,input_file=pdf,module_code='gv',pdf_dir=pdf_output_dir,overwirte=False , draw=False)\n\n\n\n\ndef main(path,headers,word_url,layout_url,download_url,upload_url,bs_url):\n pdf_names = glob.glob(path + '/*.pdf')\n \n \n return evaluate__and_save_input(pdf_names,output_path,headers,word_url,layout_url,download_url,upload_url,bs_url)\n \n\nif digitization:\n main(path,headers,word_url,layout_url,download_url,upload_url,bs_url)\n\n\ndef bound_coordinate(corrdinate,max):\n if corrdinate < 0 :\n corrdinate = 0\n if corrdinate > max:\n corrdinate = max - 2\n return int(corrdinate)\ndef get_image_from_box(image, box, height=140):\n #box = data['box']\n #scale = np.sqrt((box[1, 1] - box[2, 1])**2 + (box[0, 1] - box[3, 1])**2) / height\n #print(\"scale is \",scale)\n #w = int(np.sqrt((box[0, 0] - box[1, 0])**2 + (box[2, 0] - box[3, 0])**2) / scale)\n w = max(abs(box[0, 0] - box[1, 0]),abs(box[2, 0] - box[3, 0]))\n height = max(abs(box[0, 1] - box[3, 1]),abs(box[1, 1] - box[2, 1]))\n pts1 = np.float32(box)\n #w=2266-376\n pts2 = np.float32([[0, 0], [int(w), 0],[int(w),int(height)],[0,int(height)]])\n M = cv2.getPerspectiveTransform(pts1, pts2)\n result_img = cv2.warpPerspective(image,M,(int(w), int(height))) #flags=cv2.INTER_NEAREST\n return result_img\n\ndef process_dfs(temp_df):\n\ttemp_df = temp_df[temp_df.text.notnull()]\n\ttext = \"\"\n\tconf=0\n\ttemp_dict1 = []\n\tfor index, row in temp_df.iterrows():\n\t\ttemp_dict2 = {}\n\t\tconf = conf + row[\"conf\"]\n\t\ttemp_dict2[\"text\"]=row['text']\n\t\ttemp_dict2[\"conf\"]=row['conf']\n\t\ttext = text +\" \"+ str(row['text'])\n\t\ttemp_dict1.append(temp_dict2)\n\treturn text,temp_dict1\ndef process_dfs_updated(temp_df,language,psm_val,image):\n\ttemp_df = temp_df[temp_df.text.notnull()]\n\ttext = \"\"\n\tconf=0\n\ttemp_dict1 = []\n\tif len(temp_df)>0:\n\t\tfor index, row in temp_df.iterrows():\n\t\t\ttemp_dict2 = {}\n\t\t\torg_conf = row[\"conf\"]\n\t\t\torg_text = row['text']\n\t\t\tflag = True\n\t\t\tif row[\"conf\"]<50:\n\t\t\t\tprint(row[\"top\"],row[\"height\"],row[\"left\"],row[\"width\"])\n\t\t\t\tcrop_image = image[ int(row[\"top\"]):int(row[\"top\"]+row[\"height\"]), int(row[\"left\"]):int(row[\"left\"]+row[\"width\"])]\n\t\t\t\tfor psm in psms:\n\t\t\t\t\t\n\t\t\t\t\tdf2 = pytesseract.image_to_data(crop_image,config='--psm '+str(psm), lang=LANG_MAPPING[language][0],output_type=Output.DATAFRAME)\n\t\t\t\t\ttemp_df2 = df2[df2.text.notnull()]\n\t\t\t\t\tif len(temp_df2)>0:\n\t\t\t\t\t\tnew_conf = temp_df2.iloc[0].conf\n\t\t\t\t\t\tif org_conf<new_conf:\n\t\t\t\t\t\t\torg_conf = new_conf\n\t\t\t\t\t\t\torg_text = temp_df2.iloc[0].text\n\t\t\t\t\t\n\t\t\tif flag:\n\t\t\t\tprint(\"old text\", row['text'])\n\t\t\t\tprint(\"new text\", org_text)\t\t\n\t\t\tconf = conf + org_conf\n\t\t\ttemp_dict2[\"text\"]=org_text\n\t\t\ttemp_dict2[\"conf\"]=org_conf\n\t\t\ttext = text +\" \"+ str(org_text)\n\t\t\ttemp_dict1.append(temp_dict2)\n\treturn text,temp_dict1\n \ndef check_psm(path,coord,language,mode_height,save_base_path,psm_val,org_score,org_text,line_text,org_conf):\n\tfor psm in psms:\n\t\ttext,conf_dict = get_text(path,coord,language,mode_height,save_base_path,psm)\n\t\tif text_processing:\n\t\t\ttext_list = text.split()\n\t\t\ttext = \" \".join(text_list)\n\t\t\tscore,message,match_count = seq_matcher(text,line_text)\n\t\t\tif score==1.0 or score==1:\n\t\t\t\torg_score = score\n\t\t\t\torg_text = text\n\t\t\t\torg_conf = conf_dict\n\t\t\t\tbreak\n\t\t\telif score>org_score:\n\t\t\t\torg_score =score\n\t\t\t\torg_text = text\n\t\t\t\torg_conf = conf_dict\n\t\t\t\t\n\treturn org_text, org_conf,org_score\n\t\t\n \n \n\t\t\n\t\ndef get_text(path,coord,language,mode_height,save_base_path,psm_val):\n #try:\n\n\tpath = path.split('upload')[1]\n\n\timage = download_file(download_url,headers,path,f_type='image')\n\tnparr = np.frombuffer(image, np.uint8)\n\timage = cv2.imdecode(nparr, cv2.IMREAD_COLOR)\n\t#image = cv2.imread(\"/home/naresh/crop.jpeg\",0)\n\theight, width,channel = image.shape\n\n\t# left = bound_coordinate(coord[0] , width)\n\t# top = bound_coordinate(coord[1],height )\n\t# right = bound_coordinate(coord[2] ,width)\n\t# bottom = bound_coordinate(coord[3], height)\n\t# region_width = abs(right-left)\n\t# region_height = abs(bottom-top)\n\n\t# if left==right==top==bottom==0 or region_width==0 or region_height==0:\n\t# return \"\"\t\n\n\tcrop_image = get_image_from_box(image, coord, height=abs(coord[0,1]-coord[2,1]))\n\t#crop_image = image[ top:bottom, left:right]\n\t#crop_image_cv = image[ coord[0,1]:coord[2,1], coord[0,0]:coord[1,0]]\n\tsave_path = save_base_path+\"/\"+\"_psm_pers\"+str(psm_val)+\"--\"+str(uuid.uuid4()) + '.jpg'\n\n\tif crop_save:\n\t cv2.imwrite(save_path,crop_image)\n\n\t#if abs(bottom-top) > 3*mode_height:\n\t#print(LANG_MAPPING[language][0])\n\tif abs(coord[1,1]-coord[2,1])>mode_height:\n\t #text = pytesseract.image_to_string(crop_image,config='--psm 6', lang=LANG_MAPPING[language][1])\n\t dfs = pytesseract.image_to_data(crop_image,config='--psm 6', lang=LANG_MAPPING[language][0],output_type=Output.DATAFRAME)\n\t #text,conf_dict = process_dfs(dfs)\n\t text,conf_dict = process_dfs_updated(dfs,language,6,crop_image)\n\t \n\telse:\n\t #text = pytesseract.image_to_string(crop_image,config='--psm '+str(psm_val), lang=LANG_MAPPING[language][1])\n\t dfs = pytesseract.image_to_data(crop_image,config='--psm '+str(psm_val), lang=LANG_MAPPING[language][0],output_type=Output.DATAFRAME)\n\t #text,conf_dict = process_dfs(dfs)\n\t text,conf_dict = process_dfs_updated(dfs,language,psm_val,crop_image)\n\treturn text,conf_dict\n #except:\n\n #print(\"xxxxxxxxxxxxxxxxxxxxxxxxxx\",coord)\n #print([0.0])\n #return \"\",[0.0]\n\n\ndef merger_text(line):\n text = \"\"\n word_count=0\n for word_idx, word in enumerate(line['regions']):\n if \"text\" in word.keys() and word[\"text\"].replace(\" \", \"\") != \"\":\n text = text+\" \"+ word[\"text\"]\n word_count=word_count+1\n return text, word_count\n\n\n\ndef get_coord(bbox):\n temp_box = []\n temp_box_cv = []\n temp_box.append([bbox[\"boundingBox\"]['vertices'][0]['x'],bbox[\"boundingBox\"]['vertices'][0]['y']])\n temp_box.append([bbox[\"boundingBox\"]['vertices'][1]['x'],bbox[\"boundingBox\"]['vertices'][1]['y']])\n temp_box.append([bbox[\"boundingBox\"]['vertices'][2]['x'],bbox[\"boundingBox\"]['vertices'][2]['y']])\n temp_box.append([bbox[\"boundingBox\"]['vertices'][3]['x'],bbox[\"boundingBox\"]['vertices'][3]['y']])\n \n temp_box_cv.append(bbox[\"boundingBox\"]['vertices'][0]['x'])\n temp_box_cv.append(bbox[\"boundingBox\"]['vertices'][0]['y'])\n temp_box_cv.append(bbox[\"boundingBox\"]['vertices'][2]['x'])\n temp_box_cv.append(bbox[\"boundingBox\"]['vertices'][2]['y'])\n temp_box = np.array(temp_box)\n return temp_box,temp_box_cv\ndef frequent_height(page_info):\n text_height = []\n if len(page_info) > 0 :\n for idx, level in enumerate(page_info):\n coord_crop,coord = get_coord(level)\n if len(coord)!=0:\n text_height.append(abs(coord[3]-coord[1]))\n occurence_count = Counter(text_height)\n return occurence_count.most_common(1)[0][0]\n else :\n return 0\ndef remove_space(a):\n return a.replace(\" \", \"\")\n\ndef seq_matcher(tgt_text,gt_text):\n tgt_text = remove_space(tgt_text)\n gt_text = remove_space(gt_text)\n score = SequenceMatcher(None, gt_text, tgt_text).ratio()\n mismatch_count = levenshtein(tgt_text, gt_text)\n match_count = abs(len(gt_text)-mismatch_count)\n score = match_count/len(gt_text)\n \n\n# matchs = list(SequenceMatcher(None, gt_text, tgt_text).get_matching_blocks())\n# match_count=0\n## match_lis = []\n# for match in matchs:\n# match_count = match_count + match.size\n \n message = {\"ground\":True,\"input\":True}\n if score==0.0:\n if len(gt_text)>0 and len(tgt_text)==0:\n message['input'] = \"text missing in tesseract\"\n if len(gt_text)==0 and len(tgt_text)>0:\n message['ground'] = \"text missing in google vision\"\n if score==1.0 and len(gt_text)==0 and len(tgt_text)==0:\n message['ground'] = \"text missing in google vision\"\n message['input'] = \"text missing in tesseract\"\n return score,message,match_count\n\ndef count_mismatch_char(gt ,tgt) :\n count=0\n gt_count = len(gt)\n for i,j in zip(gt,tgt):\n if i==j:\n count=count+1\n mismatch_char = abs(gt_count-count)\n return mismatch_char\ndef correct_region(region):\n box = region['boundingBox']['vertices']\n tmp=0\n \n region['boundingBox']= {'vertices' : [{'x':box[0]['x']-crop_factor,'y':box[0]['y']-crop_factor_y},\\\n {'x':box[1]['x']+crop_factor+tmp,'y':box[1]['y']-crop_factor_y},\\\n {'x':box[2]['x']+crop_factor+tmp,'y':box[2]['y']+crop_factor_y},\\\n {'x':box[3]['x']-crop_factor,'y': box[3]['y']+crop_factor_y}]}\n return region\n \n\n\ndef sort_line(line):\n line['regions'].sort(key=lambda x: x['boundingBox']['vertices'][0]['x'],reverse=False)\n return line\n\n\ndef cell_ocr_word(lang, page_path, line,save_base_path,mode_height):\n cell_text =\"\"\n conf_dicts=[]\n #updated_lines = horzontal_merging(line['regions'])\n dynamic_line = coord_adjustment(page_path,line['regions'] ,save_base_path)\n for word_idx, word in enumerate(dynamic_line):\n word = correct_region(word)\n coord_crop, coord = get_coord(word)\n if len(coord)!=0 and abs(coord_crop[1,1]-coord_crop[2,1]) > REJECT_FILTER :\n text,conf_dict = get_text(page_path, coord_crop, lang,mode_height,save_base_path,8) \n cell_text = cell_text +\" \" +text\n conf_dicts.extend(conf_dict)\n return cell_text,conf_dicts\n\ndef cell_text_ocr(lang, page_path, line,save_base_path,mode_height):\n cell_text =\"\"\n cell_regions = []\n #updated_lines = horzontal_merging(line['regions'])\n for word_idx, word in enumerate(line['regions']):\n word = correct_region(word)\n coord_crop, coord = get_coord(word)\n if len(coord)!=0 and abs(coord_crop[1,1]-coord_crop[2,1]) > REJECT_FILTER :\n text,conf_dict = get_text(page_path, coord_crop, lang,mode_height,save_base_path,8) \n cell_text = cell_text +\" \" +text\n return cell_text\n\ndef cell_ocr(lang, page_path, line,save_base_path,mode_height,psm):\n text =\"\"\n cell_google_text = \"\"\n conf_dicts = []\n updated_lines = horzontal_merging(line['regions'])\n dynamic_line = coord_adjustment(page_path,updated_lines ,save_base_path)\n \n for updated_line in dynamic_line:\n line_text = updated_line['text']\n cell_google_text= cell_google_text + \" \"+line_text\n corrected_line = correct_region(updated_line)\n coord_crop, coord = get_coord(corrected_line)\n if len(coord)!=0 and abs(coord_crop[1,1]-coord_crop[2,1]) > REJECT_FILTER :\n tess_text,conf_dict = get_text(page_path, coord_crop, lang,mode_height,save_base_path,psm) \n text = text + \" \" + tess_text\n conf_dicts.extend(conf_dict)\n \n return cell_google_text,text,conf_dicts\n\ndef text_extraction(df,lang, page_path, regions,save_base_path):\n final_score = 0\n total_words = 0\n total_lines = 0\n total_chars = 0\n total_match_chars = 0\n for idx, level in enumerate(regions):\n mode_height = frequent_height(level['regions'])\n\n if ocr_level==\"WORD\":\n for line_idx, line in enumerate(level['regions']):\n #word_regions = coord_adjustment(page_path, line['regions'],save_base_path)\n for word_idx, word in enumerate(line['regions']):\n word = correct_region(word)\n coord_crop, coord = get_coord(word)\n word_text = word['text']\n if len(word_text)>0 and len(coord)!=0 and abs(coord_crop[1,1]-coord_crop[2,1]) > REJECT_FILTER :\n text,conf_dict = get_text(page_path, coord_crop, lang,mode_height,save_base_path,8)\n if text_processing:\n text_list = text.split()\n text = \" \".join(text_list)\n score,message,match_count = seq_matcher(text,word['text'])\n final_score = final_score+score\n total_words = total_words+1\n total_chars = total_chars+len(remove_space(word['text']))\n total_match_chars= total_match_chars+match_count\n word['char_match'] = match_count\n word['tess_text'] = text\n word['conf_dict'] = conf_dict\n word['score'] = score\n word['message'] = message\n columns = word.keys()\n df2 = pd.DataFrame([word],columns=columns)\n df = df.append(df2, ignore_index=True)\n elif len(word_text)>0:\n score,message,match_count = seq_matcher(\"\",word['text'])\n word['char_match'] = match_count\n word['tess_text'] = \" \"\n word['conf_dict'] = None\n word['score'] = score\n word['message'] = message\n columns = word.keys()\n df2 = pd.DataFrame([word],columns=columns)\n df = df.append(df2, ignore_index=True)\n if ocr_level==\"LINE\":\n lines_adjusted = coord_adjustment(page_path, level['regions'],save_base_path)\n for line_idx, line_org in enumerate(lines_adjusted):\n line_sorted = copy.deepcopy(sort_line(line_org))\n line_text,total_word = merger_text(line_sorted)\n line = copy.deepcopy(correct_region(line_sorted))\n psm = 7\n \n if total_word<2:\n #print(line_text)\n psm=8\n coord_crop, coord = get_coord(line)\n\n print(\"line text\",line_text)\n if len(remove_space(line_text))>0 and len(coord)!=0 and abs(coord_crop[1,1]-coord_crop[2,1]) > REJECT_FILTER :\n if 'class' in line.keys() and line['class']==\"CELL\":\n line_text,text,conf_dict = cell_ocr(lang, page_path, line,save_base_path,mode_height,psm)\n elif 'class' in line.keys() and line['class']==\"CELL_TEXT\":\n text,conf_dict = cell_ocr_word(lang, page_path, line,save_base_path,mode_height)\n else:\n \n text,conf_dict = get_text(page_path, coord_crop, lang,mode_height,save_base_path,psm)\n \n if text_processing:\n text_list = text.split()\n text = \" \".join(text_list)\n score,message,match_count = seq_matcher(text,line_text)\n #if score < 1.0:\n #text, conf_dict,score = check_psm(page_path,coord_crop,lang,mode_height,save_base_path,psm,score,text,line_text,conf_dict)\n final_score = final_score+score\n total_lines = total_lines+1\n total_chars = total_chars+len(remove_space(line_text))\n total_match_chars= total_match_chars+match_count\n line['char_match'] = match_count\n line['tess_text'] = text\n line['text'] = line_text \n line['conf_dict'] = conf_dict\n line['score'] = score\n line['message'] = message\n columns = line.keys()\n df2 = pd.DataFrame([line],columns=columns)\n df = df.append(df2, ignore_index=True)\n elif len(remove_space(line_text))>0:\n score,message,match_count = seq_matcher(\"\",line_text)\n line['char_match'] = match_count\n line['tess_text'] = \" \"\n line['conf_dict'] = None\n line['text'] = line_text\n line['score'] = score\n line['message'] = message\n columns = line.keys()\n df2 = pd.DataFrame([line],columns=columns)\n df = df.append(df2, ignore_index=True)\n\n #return regions,final_score/total_words,df,total_chars,total_match_chars\n return regions,final_score/total_lines,df,total_chars,total_match_chars\n\n\njson_files_path = glob.glob(output_path+\"/*/gv.json\")\n\n\ndef tesseract(json_files):\n \n output = []\n dfs =[]\n for json_file in json_files:\n file_name = json_file.split('/')[-1].split('.json')[0]\n pdf_name = json_file.split('/')[-2]\n print(\"file name--------------------->>>>>>>>>>>>>>>>>>\",pdf_name)\n if not os.path.exists(base_path+pdf_name):\n os.mkdir(base_path+pdf_name)\n save_base_path = base_path+pdf_name\n with open(json_file,'r+') as f:\n data = json.load(f)\n columns = [\"page_path\",\"page_data\",\"file_eval_info\"]\n final_df = pd.DataFrame(columns=columns)\n Draw(data,save_base_path,regions='regions')\n lang = data['outputs'][0]['config']['OCR']['language']\n total_page = len(data['outputs'][0]['pages'])\n file_score = 0; total_chars_file = 0\n file_data = []; total_match_chars_file = 0\n page_paths = []\n page_data_counts = []\n for idx,page_data in enumerate(data['outputs'][0]['pages']):\n t1 = time.time()\n print(\"processing started for page no. \",idx)\n page_path = page_data['path']\n regions = page_data['regions'][1:]\n df = pd.DataFrame()\n regions,score,df,total_chars,total_match_chars = text_extraction(df,lang, page_path, regions,save_base_path)\n file_score = file_score + score\n total_chars_file =total_chars_file +total_chars\n total_match_chars_file = total_match_chars_file+total_match_chars\n file_data.append(df.to_csv())\n page_paths.append(page_path)\n char_details = {\"total_chars\":total_chars,\"total_match_chars\":total_match_chars}\n page_data_counts.append(char_details)\n data['outputs'][0]['pages'][idx][\"regions\"][1:] = copy.deepcopy(regions)\n t2 = t1+time.time()\n print(\"processing completed for page in {}\".format(t2))\n file_eval_info = {\"total_chars\":total_chars_file,\"total_match_chars\":total_match_chars_file,\"score\":total_match_chars_file/total_chars_file}\n\n print(file_eval_info)\n final_df[\"page_path\"] = page_paths\n final_df[\"page_data\"] = file_data\n final_df[\"file_eval_info\"] = [file_eval_info]*len(page_paths)\n \n print(\"file level evaluation result------------------->>>>>>>>>>>>>>>>>>>>>>>>>>>\",file_eval_info)\n data['outputs'][0]['score'] = file_score/total_page\n with open(save_base_path+\"/\"+file_name+\".json\", 'w') as outfile:\n json.dump(data, outfile)\n final_df.to_csv(save_base_path+\"/\"+file_name+'.csv')\n return output,final_df\n \n\noutput,dfs = tesseract(json_files_path)\n\n\n\ndef draw_thresh_box(df,path,page_index,save_path):\n path = path.split('upload')[1]\n \n image = download_file(download_url,headers,path,f_type='image')\n nparr = np.frombuffer(image, np.uint8)\n image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)\n font = cv2.FONT_HERSHEY_SIMPLEX \n color= (255,0,0);thickness=5\n df =df.reset_index()\n for row in df.iterrows():\n row2 = row[1].to_dict()\n boxes = row2['boundingBox']\n boxes2 = ast.literal_eval(boxes)\n ground = boxes2['vertices']\n \n pts = []\n for pt in ground:\n pts.append([int(pt['x']) ,int(pt['y'])])\n cv2.polylines(image, [np.array(pts)],True, color, thickness)\n cv2.putText(image, str(row2['text']), (pts[0][0],pts[0][1]), font, \n 2, (0,0,255), 2, cv2.LINE_AA)\n cv2.putText(image, str(row2['tess_text']), (pts[1][0],pts[1][1]), font, \n 2, (0,255,0), 2, cv2.LINE_AA)\n\n image_path = os.path.join(save_path , '{}.png'.format(page_index)) \n cv2.imwrite(image_path , image)\n\ndef visualize_results(df_paths,thresh):\n for df_path in glob.glob(df_paths+\"*/*.csv\"):\n save_path = base_path + df_path.split('/')[-2]+\"/\"\n \n df = pd.read_csv(df_path)\n for idx,(page_path,page_data) in enumerate(zip(df['page_path'],df['page_data'])):\n df_string = StringIO(page_data)\n page_df = pd.read_csv(df_string, sep=\",\")\n filtered_df = page_df[page_df['score']<thresh]\n draw_thresh_box(filtered_df,page_path,idx,save_path)\n \nvisualize_results(base_path,vis_thresh)\n\n\n\n\n\n",
"# Dataset utils and dataloaders\n\nimport glob\nimport logging\nimport math\nimport os\nimport random\nimport shutil\nimport time\nfrom itertools import repeat\nfrom multiprocessing.pool import ThreadPool\nfrom pathlib import Path\nfrom threading import Thread\n\nimport cv2\nimport numpy as np\nimport torch\nimport torch.nn.functional as F\nfrom PIL import Image, ExifTags\nfrom torch.utils.data import Dataset\nfrom tqdm import tqdm\n\nfrom src.utilities.yolov5.general import xyxy2xywh, xywh2xyxy, xywhn2xyxy, xyn2xy, segment2box, segments2boxes, resample_segments, \\\n clean_str\nfrom src.utilities.yolov5.torch_utils import torch_distributed_zero_first\n\n# Parameters\nhelp_url = 'https://github.com/ultralytics/yolov5/wiki/Train-Custom-Data'\nimg_formats = ['bmp', 'jpg', 'jpeg', 'png', 'tif', 'tiff', 'dng', 'webp'] # acceptable image suffixes\nvid_formats = ['mov', 'avi', 'mp4', 'mpg', 'mpeg', 'm4v', 'wmv', 'mkv'] # acceptable video suffixes\nlogger = logging.getLogger(__name__)\n\n# Get orientation exif tag\nfor orientation in ExifTags.TAGS.keys():\n if ExifTags.TAGS[orientation] == 'Orientation':\n break\n\n\ndef get_hash(files):\n # Returns a single hash value of a list of files\n return sum(os.path.getsize(f) for f in files if os.path.isfile(f))\n\n\ndef exif_size(img):\n # Returns exif-corrected PIL size\n s = img.size # (width, height)\n try:\n rotation = dict(img._getexif().items())[orientation]\n if rotation == 6: # rotation 270\n s = (s[1], s[0])\n elif rotation == 8: # rotation 90\n s = (s[1], s[0])\n except:\n pass\n\n return s\n\n\ndef create_dataloader(path, imgsz, batch_size, stride, opt, hyp=None, augment=False, cache=False, pad=0.0, rect=False,\n rank=-1, world_size=1, workers=8, image_weights=False, quad=False, prefix=''):\n # Make sure only the first process in DDP process the dataset first, and the following others can use the cache\n with torch_distributed_zero_first(rank):\n dataset = LoadImagesAndLabels(path, imgsz, batch_size,\n augment=augment, # augment images\n hyp=hyp, # augmentation hyperparameters\n rect=rect, # rectangular training\n cache_images=cache,\n single_cls=opt.single_cls,\n stride=int(stride),\n pad=pad,\n image_weights=image_weights,\n prefix=prefix)\n\n batch_size = min(batch_size, len(dataset))\n nw = min([os.cpu_count() // world_size, batch_size if batch_size > 1 else 0, workers]) # number of workers\n sampler = torch.utils.data.distributed.DistributedSampler(dataset) if rank != -1 else None\n loader = torch.utils.data.DataLoader if image_weights else InfiniteDataLoader\n # Use torch.utils.data.DataLoader() if dataset.properties will update during training else InfiniteDataLoader()\n dataloader = loader(dataset,\n batch_size=batch_size,\n num_workers=nw,\n sampler=sampler,\n pin_memory=True,\n collate_fn=LoadImagesAndLabels.collate_fn4 if quad else LoadImagesAndLabels.collate_fn)\n return dataloader, dataset\n\n\nclass InfiniteDataLoader(torch.utils.data.dataloader.DataLoader):\n \"\"\" Dataloader that reuses workers\n\n Uses same syntax as vanilla DataLoader\n \"\"\"\n\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n object.__setattr__(self, 'batch_sampler', _RepeatSampler(self.batch_sampler))\n self.iterator = super().__iter__()\n\n def __len__(self):\n return len(self.batch_sampler.sampler)\n\n def __iter__(self):\n for i in range(len(self)):\n yield next(self.iterator)\n\n\nclass _RepeatSampler(object):\n \"\"\" Sampler that repeats forever\n\n Args:\n sampler (Sampler)\n \"\"\"\n\n def __init__(self, sampler):\n self.sampler = sampler\n\n def __iter__(self):\n while True:\n yield from iter(self.sampler)\n\n\nclass LoadImages: # for inference\n def __init__(self, path, img_size=640, stride=32):\n\n if os.path.isfile(path):\n files = [path] # files\n else:\n raise Exception(f'ERROR: {path} does not exist')\n\n images = [x for x in files if x.split('.')[-1].lower() in img_formats]\n videos = [x for x in files if x.split('.')[-1].lower() in vid_formats]\n ni, nv = len(images), len(videos)\n\n self.img_size = img_size\n self.stride = stride\n self.files = images + videos\n self.nf = ni + nv # number of files\n self.video_flag = [False] * ni + [True] * nv\n self.mode = 'image'\n if any(videos):\n self.new_video(videos[0]) # new video\n else:\n self.cap = None\n assert self.nf > 0, f'No images or videos found in {path}. ' \\\n f'Supported formats are:\\nimages: {img_formats}\\nvideos: {vid_formats}'\n\n def __iter__(self):\n self.count = 0\n return self\n\n def __next__(self):\n if self.count == self.nf:\n raise StopIteration\n path = self.files[self.count]\n\n\n # Read image\n self.count += 1\n img0 = cv2.imread(path) # BGR\n assert img0 is not None, 'Image Not Found ' + path\n print(f'image {self.count}/{self.nf} {path}: ', end='')\n\n # Padded resize\n img = letterbox(img0, self.img_size, stride=self.stride)[0]\n\n # Convert\n img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416\n img = np.ascontiguousarray(img)\n\n return path, img, img0, self.cap\n\n def new_video(self, path):\n self.frame = 0\n self.cap = cv2.VideoCapture(path)\n self.nframes = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))\n\n def __len__(self):\n return self.nf # number of files\n\n\nclass LoadWebcam: # for inference\n def __init__(self, pipe='0', img_size=640, stride=32):\n self.img_size = img_size\n self.stride = stride\n\n if pipe.isnumeric():\n pipe = eval(pipe) # local camera\n # pipe = 'rtsp://192.168.1.64/1' # IP camera\n # pipe = 'rtsp://username:[email protected]/1' # IP camera with login\n # pipe = 'http://wmccpinetop.axiscam.net/mjpg/video.mjpg' # IP golf camera\n\n self.pipe = pipe\n self.cap = cv2.VideoCapture(pipe) # video capture object\n self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 3) # set buffer size\n\n def __iter__(self):\n self.count = -1\n return self\n\n def __next__(self):\n self.count += 1\n if cv2.waitKey(1) == ord('q'): # q to quit\n self.cap.release()\n cv2.destroyAllWindows()\n raise StopIteration\n\n # Read frame\n if self.pipe == 0: # local camera\n ret_val, img0 = self.cap.read()\n img0 = cv2.flip(img0, 1) # flip left-right\n else: # IP camera\n n = 0\n while True:\n n += 1\n self.cap.grab()\n if n % 30 == 0: # skip frames\n ret_val, img0 = self.cap.retrieve()\n if ret_val:\n break\n\n # Print\n assert ret_val, f'Camera Error {self.pipe}'\n img_path = 'webcam.jpg'\n print(f'webcam {self.count}: ', end='')\n\n # Padded resize\n img = letterbox(img0, self.img_size, stride=self.stride)[0]\n\n # Convert\n img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416\n img = np.ascontiguousarray(img)\n\n return img_path, img, img0, None\n\n def __len__(self):\n return 0\n\n\nclass LoadStreams: # multiple IP or RTSP cameras\n def __init__(self, sources='streams.txt', img_size=640, stride=32):\n self.mode = 'stream'\n self.img_size = img_size\n self.stride = stride\n\n if os.path.isfile(sources):\n with open(sources, 'r') as f:\n sources = [x.strip() for x in f.read().strip().splitlines() if len(x.strip())]\n else:\n sources = [sources]\n\n n = len(sources)\n self.imgs = [None] * n\n self.sources = [clean_str(x) for x in sources] # clean source names for later\n for i, s in enumerate(sources):\n # Start the thread to read frames from the video stream\n print(f'{i + 1}/{n}: {s}... ', end='')\n cap = cv2.VideoCapture(eval(s) if s.isnumeric() else s)\n assert cap.isOpened(), f'Failed to open {s}'\n w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n fps = cap.get(cv2.CAP_PROP_FPS) % 100\n _, self.imgs[i] = cap.read() # guarantee first frame\n thread = Thread(target=self.update, args=([i, cap]), daemon=True)\n print(f' success ({w}x{h} at {fps:.2f} FPS).')\n thread.start()\n print('') # newline\n\n # check for common shapes\n s = np.stack([letterbox(x, self.img_size, stride=self.stride)[0].shape for x in self.imgs], 0) # shapes\n self.rect = np.unique(s, axis=0).shape[0] == 1 # rect inference if all shapes equal\n if not self.rect:\n print('WARNING: Different stream shapes detected. For optimal performance supply similarly-shaped streams.')\n\n def update(self, index, cap):\n # Read next stream frame in a daemon thread\n n = 0\n while cap.isOpened():\n n += 1\n # _, self.imgs[index] = cap.read()\n cap.grab()\n if n == 4: # read every 4th frame\n success, im = cap.retrieve()\n self.imgs[index] = im if success else self.imgs[index] * 0\n n = 0\n time.sleep(0.01) # wait time\n\n def __iter__(self):\n self.count = -1\n return self\n\n def __next__(self):\n self.count += 1\n img0 = self.imgs.copy()\n if cv2.waitKey(1) == ord('q'): # q to quit\n cv2.destroyAllWindows()\n raise StopIteration\n\n # Letterbox\n img = [letterbox(x, self.img_size, auto=self.rect, stride=self.stride)[0] for x in img0]\n\n # Stack\n img = np.stack(img, 0)\n\n # Convert\n img = img[:, :, :, ::-1].transpose(0, 3, 1, 2) # BGR to RGB, to bsx3x416x416\n img = np.ascontiguousarray(img)\n\n return self.sources, img, img0, None\n\n def __len__(self):\n return 0 # 1E12 frames = 32 streams at 30 FPS for 30 years\n\n\ndef img2label_paths(img_paths):\n # Define label paths as a function of image paths\n sa, sb = os.sep + 'images' + os.sep, os.sep + 'labels' + os.sep # /images/, /labels/ substrings\n return ['txt'.join(x.replace(sa, sb, 1).rsplit(x.split('.')[-1], 1)) for x in img_paths]\n\n\nclass LoadImagesAndLabels(Dataset): # for training/testing\n def __init__(self, path, img_size=640, batch_size=16, augment=False, hyp=None, rect=False, image_weights=False,\n cache_images=False, single_cls=False, stride=32, pad=0.0, prefix=''):\n self.img_size = img_size\n self.augment = augment\n self.hyp = hyp\n self.image_weights = image_weights\n self.rect = False if image_weights else rect\n self.mosaic = self.augment and not self.rect # load 4 images at a time into a mosaic (only during training)\n self.mosaic_border = [-img_size // 2, -img_size // 2]\n self.stride = stride\n self.path = path\n\n try:\n f = [] # image files\n for p in path if isinstance(path, list) else [path]:\n p = Path(p) # os-agnostic\n if p.is_dir(): # dir\n f += glob.glob(str(p / '**' / '*.*'), recursive=True)\n # f = list(p.rglob('**/*.*')) # pathlib\n elif p.is_file(): # file\n with open(p, 'r') as t:\n t = t.read().strip().splitlines()\n parent = str(p.parent) + os.sep\n f += [x.replace('./', parent) if x.startswith('./') else x for x in t] # local to global path\n # f += [p.parent / x.lstrip(os.sep) for x in t] # local to global path (pathlib)\n else:\n raise Exception(f'{prefix}{p} does not exist')\n self.img_files = sorted([x.replace('/', os.sep) for x in f if x.split('.')[-1].lower() in img_formats])\n # self.img_files = sorted([x for x in f if x.suffix[1:].lower() in img_formats]) # pathlib\n assert self.img_files, f'{prefix}No images found'\n except Exception as e:\n raise Exception(f'{prefix}Error loading data from {path}: {e}\\nSee {help_url}')\n\n # Check cache\n self.label_files = img2label_paths(self.img_files) # labels\n cache_path = (p if p.is_file() else Path(self.label_files[0]).parent).with_suffix('.cache') # cached labels\n if cache_path.is_file():\n cache, exists = torch.load(cache_path), True # load\n if cache['hash'] != get_hash(self.label_files + self.img_files) or 'version' not in cache: # changed\n cache, exists = self.cache_labels(cache_path, prefix), False # re-cache\n else:\n cache, exists = self.cache_labels(cache_path, prefix), False # cache\n\n # Display cache\n nf, nm, ne, nc, n = cache.pop('results') # found, missing, empty, corrupted, total\n if exists:\n d = f\"Scanning '{cache_path}' for images and labels... {nf} found, {nm} missing, {ne} empty, {nc} corrupted\"\n tqdm(None, desc=prefix + d, total=n, initial=n) # display cache results\n assert nf > 0 or not augment, f'{prefix}No labels in {cache_path}. Can not train without labels. See {help_url}'\n\n # Read cache\n cache.pop('hash') # remove hash\n cache.pop('version') # remove version\n labels, shapes, self.segments = zip(*cache.values())\n self.labels = list(labels)\n self.shapes = np.array(shapes, dtype=np.float64)\n self.img_files = list(cache.keys()) # update\n self.label_files = img2label_paths(cache.keys()) # update\n if single_cls:\n for x in self.labels:\n x[:, 0] = 0\n\n n = len(shapes) # number of images\n bi = np.floor(np.arange(n) / batch_size).astype(np.int) # batch index\n nb = bi[-1] + 1 # number of batches\n self.batch = bi # batch index of image\n self.n = n\n self.indices = range(n)\n\n # Rectangular Training\n if self.rect:\n # Sort by aspect ratio\n s = self.shapes # wh\n ar = s[:, 1] / s[:, 0] # aspect ratio\n irect = ar.argsort()\n self.img_files = [self.img_files[i] for i in irect]\n self.label_files = [self.label_files[i] for i in irect]\n self.labels = [self.labels[i] for i in irect]\n self.shapes = s[irect] # wh\n ar = ar[irect]\n\n # Set training image shapes\n shapes = [[1, 1]] * nb\n for i in range(nb):\n ari = ar[bi == i]\n mini, maxi = ari.min(), ari.max()\n if maxi < 1:\n shapes[i] = [maxi, 1]\n elif mini > 1:\n shapes[i] = [1, 1 / mini]\n\n self.batch_shapes = np.ceil(np.array(shapes) * img_size / stride + pad).astype(np.int) * stride\n\n # Cache images into memory for faster training (WARNING: large datasets may exceed system RAM)\n self.imgs = [None] * n\n if cache_images:\n gb = 0 # Gigabytes of cached images\n self.img_hw0, self.img_hw = [None] * n, [None] * n\n results = ThreadPool(8).imap(lambda x: load_image(*x), zip(repeat(self), range(n))) # 8 threads\n pbar = tqdm(enumerate(results), total=n)\n for i, x in pbar:\n self.imgs[i], self.img_hw0[i], self.img_hw[i] = x # img, hw_original, hw_resized = load_image(self, i)\n gb += self.imgs[i].nbytes\n pbar.desc = f'{prefix}Caching images ({gb / 1E9:.1f}GB)'\n\n def cache_labels(self, path=Path('./labels.cache'), prefix=''):\n # Cache dataset labels, check images and read shapes\n x = {} # dict\n nm, nf, ne, nc = 0, 0, 0, 0 # number missing, found, empty, duplicate\n pbar = tqdm(zip(self.img_files, self.label_files), desc='Scanning images', total=len(self.img_files))\n for i, (im_file, lb_file) in enumerate(pbar):\n try:\n # verify images\n im = Image.open(im_file)\n im.verify() # PIL verify\n shape = exif_size(im) # image size\n segments = [] # instance segments\n assert (shape[0] > 9) & (shape[1] > 9), f'image size {shape} <10 pixels'\n assert im.format.lower() in img_formats, f'invalid image format {im.format}'\n\n # verify labels\n if os.path.isfile(lb_file):\n nf += 1 # label found\n with open(lb_file, 'r') as f:\n l = [x.split() for x in f.read().strip().splitlines()]\n if any([len(x) > 8 for x in l]): # is segment\n classes = np.array([x[0] for x in l], dtype=np.float32)\n segments = [np.array(x[1:], dtype=np.float32).reshape(-1, 2) for x in l] # (cls, xy1...)\n l = np.concatenate((classes.reshape(-1, 1), segments2boxes(segments)), 1) # (cls, xywh)\n l = np.array(l, dtype=np.float32)\n if len(l):\n assert l.shape[1] == 5, 'labels require 5 columns each'\n assert (l >= 0).all(), 'negative labels'\n assert (l[:, 1:] <= 1).all(), 'non-normalized or out of bounds coordinate labels'\n assert np.unique(l, axis=0).shape[0] == l.shape[0], 'duplicate labels'\n else:\n ne += 1 # label empty\n l = np.zeros((0, 5), dtype=np.float32)\n else:\n nm += 1 # label missing\n l = np.zeros((0, 5), dtype=np.float32)\n x[im_file] = [l, shape, segments]\n except Exception as e:\n nc += 1\n print(f'{prefix}WARNING: Ignoring corrupted image and/or label {im_file}: {e}')\n\n pbar.desc = f\"{prefix}Scanning '{path.parent / path.stem}' for images and labels... \" \\\n f\"{nf} found, {nm} missing, {ne} empty, {nc} corrupted\"\n\n if nf == 0:\n print(f'{prefix}WARNING: No labels found in {path}. See {help_url}')\n\n x['hash'] = get_hash(self.label_files + self.img_files)\n x['results'] = nf, nm, ne, nc, i + 1\n x['version'] = 0.1 # cache version\n torch.save(x, path) # save for next time\n logging.info(f'{prefix}New cache created: {path}')\n return x\n\n def __len__(self):\n return len(self.img_files)\n\n # def __iter__(self):\n # self.count = -1\n # print('ran dataset iter')\n # #self.shuffled_vector = np.random.permutation(self.nF) if self.augment else np.arange(self.nF)\n # return self\n\n def __getitem__(self, index):\n index = self.indices[index] # linear, shuffled, or image_weights\n\n hyp = self.hyp\n mosaic = self.mosaic and random.random() < hyp['mosaic']\n if mosaic:\n # Load mosaic\n img, labels = load_mosaic(self, index)\n shapes = None\n\n # MixUp https://arxiv.org/pdf/1710.09412.pdf\n if random.random() < hyp['mixup']:\n img2, labels2 = load_mosaic(self, random.randint(0, self.n - 1))\n r = np.random.beta(8.0, 8.0) # mixup ratio, alpha=beta=8.0\n img = (img * r + img2 * (1 - r)).astype(np.uint8)\n labels = np.concatenate((labels, labels2), 0)\n\n else:\n # Load image\n img, (h0, w0), (h, w) = load_image(self, index)\n\n # Letterbox\n shape = self.batch_shapes[self.batch[index]] if self.rect else self.img_size # final letterboxed shape\n img, ratio, pad = letterbox(img, shape, auto=False, scaleup=self.augment)\n shapes = (h0, w0), ((h / h0, w / w0), pad) # for COCO mAP rescaling\n\n labels = self.labels[index].copy()\n if labels.size: # normalized xywh to pixel xyxy format\n labels[:, 1:] = xywhn2xyxy(labels[:, 1:], ratio[0] * w, ratio[1] * h, padw=pad[0], padh=pad[1])\n\n if self.augment:\n # Augment imagespace\n if not mosaic:\n img, labels = random_perspective(img, labels,\n degrees=hyp['degrees'],\n translate=hyp['translate'],\n scale=hyp['scale'],\n shear=hyp['shear'],\n perspective=hyp['perspective'])\n\n # Augment colorspace\n augment_hsv(img, hgain=hyp['hsv_h'], sgain=hyp['hsv_s'], vgain=hyp['hsv_v'])\n\n # Apply cutouts\n # if random.random() < 0.9:\n # labels = cutout(img, labels)\n\n nL = len(labels) # number of labels\n if nL:\n labels[:, 1:5] = xyxy2xywh(labels[:, 1:5]) # convert xyxy to xywh\n labels[:, [2, 4]] /= img.shape[0] # normalized height 0-1\n labels[:, [1, 3]] /= img.shape[1] # normalized width 0-1\n\n if self.augment:\n # flip up-down\n if random.random() < hyp['flipud']:\n img = np.flipud(img)\n if nL:\n labels[:, 2] = 1 - labels[:, 2]\n\n # flip left-right\n if random.random() < hyp['fliplr']:\n img = np.fliplr(img)\n if nL:\n labels[:, 1] = 1 - labels[:, 1]\n\n labels_out = torch.zeros((nL, 6))\n if nL:\n labels_out[:, 1:] = torch.from_numpy(labels)\n\n # Convert\n img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416\n img = np.ascontiguousarray(img)\n\n return torch.from_numpy(img), labels_out, self.img_files[index], shapes\n\n @staticmethod\n def collate_fn(batch):\n img, label, path, shapes = zip(*batch) # transposed\n for i, l in enumerate(label):\n l[:, 0] = i # add target image index for build_targets()\n return torch.stack(img, 0), torch.cat(label, 0), path, shapes\n\n @staticmethod\n def collate_fn4(batch):\n img, label, path, shapes = zip(*batch) # transposed\n n = len(shapes) // 4\n img4, label4, path4, shapes4 = [], [], path[:n], shapes[:n]\n\n ho = torch.tensor([[0., 0, 0, 1, 0, 0]])\n wo = torch.tensor([[0., 0, 1, 0, 0, 0]])\n s = torch.tensor([[1, 1, .5, .5, .5, .5]]) # scale\n for i in range(n): # zidane torch.zeros(16,3,720,1280) # BCHW\n i *= 4\n if random.random() < 0.5:\n im = F.interpolate(img[i].unsqueeze(0).float(), scale_factor=2., mode='bilinear', align_corners=False)[\n 0].type(img[i].type())\n l = label[i]\n else:\n im = torch.cat((torch.cat((img[i], img[i + 1]), 1), torch.cat((img[i + 2], img[i + 3]), 1)), 2)\n l = torch.cat((label[i], label[i + 1] + ho, label[i + 2] + wo, label[i + 3] + ho + wo), 0) * s\n img4.append(im)\n label4.append(l)\n\n for i, l in enumerate(label4):\n l[:, 0] = i # add target image index for build_targets()\n\n return torch.stack(img4, 0), torch.cat(label4, 0), path4, shapes4\n\n\n# Ancillary functions --------------------------------------------------------------------------------------------------\ndef load_image(self, index):\n # loads 1 image from dataset, returns img, original hw, resized hw\n img = self.imgs[index]\n if img is None: # not cached\n path = self.img_files[index]\n img = cv2.imread(path) # BGR\n assert img is not None, 'Image Not Found ' + path\n h0, w0 = img.shape[:2] # orig hw\n r = self.img_size / max(h0, w0) # resize image to img_size\n if r != 1: # always resize down, only resize up if training with augmentation\n interp = cv2.INTER_AREA if r < 1 and not self.augment else cv2.INTER_LINEAR\n img = cv2.resize(img, (int(w0 * r), int(h0 * r)), interpolation=interp)\n return img, (h0, w0), img.shape[:2] # img, hw_original, hw_resized\n else:\n return self.imgs[index], self.img_hw0[index], self.img_hw[index] # img, hw_original, hw_resized\n\n\ndef augment_hsv(img, hgain=0.5, sgain=0.5, vgain=0.5):\n r = np.random.uniform(-1, 1, 3) * [hgain, sgain, vgain] + 1 # random gains\n hue, sat, val = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV))\n dtype = img.dtype # uint8\n\n x = np.arange(0, 256, dtype=np.int16)\n lut_hue = ((x * r[0]) % 180).astype(dtype)\n lut_sat = np.clip(x * r[1], 0, 255).astype(dtype)\n lut_val = np.clip(x * r[2], 0, 255).astype(dtype)\n\n img_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat), cv2.LUT(val, lut_val))).astype(dtype)\n cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img) # no return needed\n\n\ndef hist_equalize(img, clahe=True, bgr=False):\n # Equalize histogram on BGR image 'img' with img.shape(n,m,3) and range 0-255\n yuv = cv2.cvtColor(img, cv2.COLOR_BGR2YUV if bgr else cv2.COLOR_RGB2YUV)\n if clahe:\n c = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))\n yuv[:, :, 0] = c.apply(yuv[:, :, 0])\n else:\n yuv[:, :, 0] = cv2.equalizeHist(yuv[:, :, 0]) # equalize Y channel histogram\n return cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR if bgr else cv2.COLOR_YUV2RGB) # convert YUV image to RGB\n\n\ndef load_mosaic(self, index):\n # loads images in a 4-mosaic\n\n labels4, segments4 = [], []\n s = self.img_size\n yc, xc = [int(random.uniform(-x, 2 * s + x)) for x in self.mosaic_border] # mosaic center x, y\n indices = [index] + [self.indices[random.randint(0, self.n - 1)] for _ in range(3)] # 3 additional image indices\n for i, index in enumerate(indices):\n # Load image\n img, _, (h, w) = load_image(self, index)\n\n # place img in img4\n if i == 0: # top left\n img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles\n x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc # xmin, ymin, xmax, ymax (large image)\n x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h # xmin, ymin, xmax, ymax (small image)\n elif i == 1: # top right\n x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc\n x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h\n elif i == 2: # bottom left\n x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h)\n x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h)\n elif i == 3: # bottom right\n x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h)\n x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h)\n\n img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] # img4[ymin:ymax, xmin:xmax]\n padw = x1a - x1b\n padh = y1a - y1b\n\n # Labels\n labels, segments = self.labels[index].copy(), self.segments[index].copy()\n if labels.size:\n labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh) # normalized xywh to pixel xyxy format\n segments = [xyn2xy(x, w, h, padw, padh) for x in segments]\n labels4.append(labels)\n segments4.extend(segments)\n\n # Concat/clip labels\n labels4 = np.concatenate(labels4, 0)\n for x in (labels4[:, 1:], *segments4):\n np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective()\n # img4, labels4 = replicate(img4, labels4) # replicate\n\n # Augment\n img4, labels4 = random_perspective(img4, labels4, segments4,\n degrees=self.hyp['degrees'],\n translate=self.hyp['translate'],\n scale=self.hyp['scale'],\n shear=self.hyp['shear'],\n perspective=self.hyp['perspective'],\n border=self.mosaic_border) # border to remove\n\n return img4, labels4\n\n\ndef load_mosaic9(self, index):\n # loads images in a 9-mosaic\n\n labels9, segments9 = [], []\n s = self.img_size\n indices = [index] + [self.indices[random.randint(0, self.n - 1)] for _ in range(8)] # 8 additional image indices\n for i, index in enumerate(indices):\n # Load image\n img, _, (h, w) = load_image(self, index)\n\n # place img in img9\n if i == 0: # center\n img9 = np.full((s * 3, s * 3, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles\n h0, w0 = h, w\n c = s, s, s + w, s + h # xmin, ymin, xmax, ymax (base) coordinates\n elif i == 1: # top\n c = s, s - h, s + w, s\n elif i == 2: # top right\n c = s + wp, s - h, s + wp + w, s\n elif i == 3: # right\n c = s + w0, s, s + w0 + w, s + h\n elif i == 4: # bottom right\n c = s + w0, s + hp, s + w0 + w, s + hp + h\n elif i == 5: # bottom\n c = s + w0 - w, s + h0, s + w0, s + h0 + h\n elif i == 6: # bottom left\n c = s + w0 - wp - w, s + h0, s + w0 - wp, s + h0 + h\n elif i == 7: # left\n c = s - w, s + h0 - h, s, s + h0\n elif i == 8: # top left\n c = s - w, s + h0 - hp - h, s, s + h0 - hp\n\n padx, pady = c[:2]\n x1, y1, x2, y2 = [max(x, 0) for x in c] # allocate coords\n\n # Labels\n labels, segments = self.labels[index].copy(), self.segments[index].copy()\n if labels.size:\n labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padx, pady) # normalized xywh to pixel xyxy format\n segments = [xyn2xy(x, w, h, padx, pady) for x in segments]\n labels9.append(labels)\n segments9.extend(segments)\n\n # Image\n img9[y1:y2, x1:x2] = img[y1 - pady:, x1 - padx:] # img9[ymin:ymax, xmin:xmax]\n hp, wp = h, w # height, width previous\n\n # Offset\n yc, xc = [int(random.uniform(0, s)) for _ in self.mosaic_border] # mosaic center x, y\n img9 = img9[yc:yc + 2 * s, xc:xc + 2 * s]\n\n # Concat/clip labels\n labels9 = np.concatenate(labels9, 0)\n labels9[:, [1, 3]] -= xc\n labels9[:, [2, 4]] -= yc\n c = np.array([xc, yc]) # centers\n segments9 = [x - c for x in segments9]\n\n for x in (labels9[:, 1:], *segments9):\n np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective()\n # img9, labels9 = replicate(img9, labels9) # replicate\n\n # Augment\n img9, labels9 = random_perspective(img9, labels9, segments9,\n degrees=self.hyp['degrees'],\n translate=self.hyp['translate'],\n scale=self.hyp['scale'],\n shear=self.hyp['shear'],\n perspective=self.hyp['perspective'],\n border=self.mosaic_border) # border to remove\n\n return img9, labels9\n\n\ndef replicate(img, labels):\n # Replicate labels\n h, w = img.shape[:2]\n boxes = labels[:, 1:].astype(int)\n x1, y1, x2, y2 = boxes.T\n s = ((x2 - x1) + (y2 - y1)) / 2 # side length (pixels)\n for i in s.argsort()[:round(s.size * 0.5)]: # smallest indices\n x1b, y1b, x2b, y2b = boxes[i]\n bh, bw = y2b - y1b, x2b - x1b\n yc, xc = int(random.uniform(0, h - bh)), int(random.uniform(0, w - bw)) # offset x, y\n x1a, y1a, x2a, y2a = [xc, yc, xc + bw, yc + bh]\n img[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] # img4[ymin:ymax, xmin:xmax]\n labels = np.append(labels, [[labels[i, 0], x1a, y1a, x2a, y2a]], axis=0)\n\n return img, labels\n\n\ndef letterbox(img, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True, stride=32):\n # Resize and pad image while meeting stride-multiple constraints\n shape = img.shape[:2] # current shape [height, width]\n if isinstance(new_shape, int):\n new_shape = (new_shape, new_shape)\n\n # Scale ratio (new / old)\n r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])\n if not scaleup: # only scale down, do not scale up (for better test mAP)\n r = min(r, 1.0)\n\n # Compute padding\n ratio = r, r # width, height ratios\n new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))\n dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding\n if auto: # minimum rectangle\n dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding\n elif scaleFill: # stretch\n dw, dh = 0.0, 0.0\n new_unpad = (new_shape[1], new_shape[0])\n ratio = new_shape[1] / shape[1], new_shape[0] / shape[0] # width, height ratios\n\n dw /= 2 # divide padding into 2 sides\n dh /= 2\n\n if shape[::-1] != new_unpad: # resize\n img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)\n top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))\n left, right = int(round(dw - 0.1)), int(round(dw + 0.1))\n img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border\n return img, ratio, (dw, dh)\n\n\ndef random_perspective(img, targets=(), segments=(), degrees=10, translate=.1, scale=.1, shear=10, perspective=0.0,\n border=(0, 0)):\n # torchvision.transforms.RandomAffine(degrees=(-10, 10), translate=(.1, .1), scale=(.9, 1.1), shear=(-10, 10))\n # targets = [cls, xyxy]\n\n height = img.shape[0] + border[0] * 2 # shape(h,w,c)\n width = img.shape[1] + border[1] * 2\n\n # Center\n C = np.eye(3)\n C[0, 2] = -img.shape[1] / 2 # x translation (pixels)\n C[1, 2] = -img.shape[0] / 2 # y translation (pixels)\n\n # Perspective\n P = np.eye(3)\n P[2, 0] = random.uniform(-perspective, perspective) # x perspective (about y)\n P[2, 1] = random.uniform(-perspective, perspective) # y perspective (about x)\n\n # Rotation and Scale\n R = np.eye(3)\n a = random.uniform(-degrees, degrees)\n # a += random.choice([-180, -90, 0, 90]) # add 90deg rotations to small rotations\n s = random.uniform(1 - scale, 1 + scale)\n # s = 2 ** random.uniform(-scale, scale)\n R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s)\n\n # Shear\n S = np.eye(3)\n S[0, 1] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # x shear (deg)\n S[1, 0] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # y shear (deg)\n\n # Translation\n T = np.eye(3)\n T[0, 2] = random.uniform(0.5 - translate, 0.5 + translate) * width # x translation (pixels)\n T[1, 2] = random.uniform(0.5 - translate, 0.5 + translate) * height # y translation (pixels)\n\n # Combined rotation matrix\n M = T @ S @ R @ P @ C # order of operations (right to left) is IMPORTANT\n if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any(): # image changed\n if perspective:\n img = cv2.warpPerspective(img, M, dsize=(width, height), borderValue=(114, 114, 114))\n else: # affine\n img = cv2.warpAffine(img, M[:2], dsize=(width, height), borderValue=(114, 114, 114))\n\n # Visualize\n # import matplotlib.pyplot as plt\n # ax = plt.subplots(1, 2, figsize=(12, 6))[1].ravel()\n # ax[0].imshow(img[:, :, ::-1]) # base\n # ax[1].imshow(img2[:, :, ::-1]) # warped\n\n # Transform label coordinates\n n = len(targets)\n if n:\n use_segments = any(x.any() for x in segments)\n new = np.zeros((n, 4))\n if use_segments: # warp segments\n segments = resample_segments(segments) # upsample\n for i, segment in enumerate(segments):\n xy = np.ones((len(segment), 3))\n xy[:, :2] = segment\n xy = xy @ M.T # transform\n xy = xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2] # perspective rescale or affine\n\n # clip\n new[i] = segment2box(xy, width, height)\n\n else: # warp boxes\n xy = np.ones((n * 4, 3))\n xy[:, :2] = targets[:, [1, 2, 3, 4, 1, 4, 3, 2]].reshape(n * 4, 2) # x1y1, x2y2, x1y2, x2y1\n xy = xy @ M.T # transform\n xy = (xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2]).reshape(n, 8) # perspective rescale or affine\n\n # create new boxes\n x = xy[:, [0, 2, 4, 6]]\n y = xy[:, [1, 3, 5, 7]]\n new = np.concatenate((x.min(1), y.min(1), x.max(1), y.max(1))).reshape(4, n).T\n\n # clip\n new[:, [0, 2]] = new[:, [0, 2]].clip(0, width)\n new[:, [1, 3]] = new[:, [1, 3]].clip(0, height)\n\n # filter candidates\n i = box_candidates(box1=targets[:, 1:5].T * s, box2=new.T, area_thr=0.01 if use_segments else 0.10)\n targets = targets[i]\n targets[:, 1:5] = new[i]\n\n return img, targets\n\n\ndef box_candidates(box1, box2, wh_thr=2, ar_thr=20, area_thr=0.1, eps=1e-16): # box1(4,n), box2(4,n)\n # Compute candidate boxes: box1 before augment, box2 after augment, wh_thr (pixels), aspect_ratio_thr, area_ratio\n w1, h1 = box1[2] - box1[0], box1[3] - box1[1]\n w2, h2 = box2[2] - box2[0], box2[3] - box2[1]\n ar = np.maximum(w2 / (h2 + eps), h2 / (w2 + eps)) # aspect ratio\n return (w2 > wh_thr) & (h2 > wh_thr) & (w2 * h2 / (w1 * h1 + eps) > area_thr) & (ar < ar_thr) # candidates\n\n\ndef cutout(image, labels):\n # Applies image cutout augmentation https://arxiv.org/abs/1708.04552\n h, w = image.shape[:2]\n\n def bbox_ioa(box1, box2):\n # Returns the intersection over box2 area given box1, box2. box1 is 4, box2 is nx4. boxes are x1y1x2y2\n box2 = box2.transpose()\n\n # Get the coordinates of bounding boxes\n b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]\n b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]\n\n # Intersection area\n inter_area = (np.minimum(b1_x2, b2_x2) - np.maximum(b1_x1, b2_x1)).clip(0) * \\\n (np.minimum(b1_y2, b2_y2) - np.maximum(b1_y1, b2_y1)).clip(0)\n\n # box2 area\n box2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1) + 1e-16\n\n # Intersection over box2 area\n return inter_area / box2_area\n\n # create random masks\n scales = [0.5] * 1 + [0.25] * 2 + [0.125] * 4 + [0.0625] * 8 + [0.03125] * 16 # image size fraction\n for s in scales:\n mask_h = random.randint(1, int(h * s))\n mask_w = random.randint(1, int(w * s))\n\n # box\n xmin = max(0, random.randint(0, w) - mask_w // 2)\n ymin = max(0, random.randint(0, h) - mask_h // 2)\n xmax = min(w, xmin + mask_w)\n ymax = min(h, ymin + mask_h)\n\n # apply random color mask\n image[ymin:ymax, xmin:xmax] = [random.randint(64, 191) for _ in range(3)]\n\n # return unobscured labels\n if len(labels) and s > 0.03:\n box = np.array([xmin, ymin, xmax, ymax], dtype=np.float32)\n ioa = bbox_ioa(box, labels[:, 1:5]) # intersection over area\n labels = labels[ioa < 0.60] # remove >60% obscured labels\n\n return labels\n\n\ndef create_folder(path='./new'):\n # Create folder\n if os.path.exists(path):\n shutil.rmtree(path) # delete output folder\n os.makedirs(path) # make new output folder\n\n\ndef flatten_recursive(path='../coco128'):\n # Flatten a recursive directory by bringing all files to top level\n new_path = Path(path + '_flat')\n create_folder(new_path)\n for file in tqdm(glob.glob(str(Path(path)) + '/**/*.*', recursive=True)):\n shutil.copyfile(file, new_path / Path(file).name)\n\n\ndef extract_boxes(path='../coco128/'): # from utils.datasets import *; extract_boxes('../coco128')\n # Convert detection dataset into classification dataset, with one directory per class\n\n path = Path(path) # images dir\n shutil.rmtree(path / 'classifier') if (path / 'classifier').is_dir() else None # remove existing\n files = list(path.rglob('*.*'))\n n = len(files) # number of files\n for im_file in tqdm(files, total=n):\n if im_file.suffix[1:] in img_formats:\n # image\n im = cv2.imread(str(im_file))[..., ::-1] # BGR to RGB\n h, w = im.shape[:2]\n\n # labels\n lb_file = Path(img2label_paths([str(im_file)])[0])\n if Path(lb_file).exists():\n with open(lb_file, 'r') as f:\n lb = np.array([x.split() for x in f.read().strip().splitlines()], dtype=np.float32) # labels\n\n for j, x in enumerate(lb):\n c = int(x[0]) # class\n f = (path / 'classifier') / f'{c}' / f'{path.stem}_{im_file.stem}_{j}.jpg' # new filename\n if not f.parent.is_dir():\n f.parent.mkdir(parents=True)\n\n b = x[1:] * [w, h, w, h] # box\n # b[2:] = b[2:].max() # rectangle to square\n b[2:] = b[2:] * 1.2 + 3 # pad\n b = xywh2xyxy(b.reshape(-1, 4)).ravel().astype(np.int)\n\n b[[0, 2]] = np.clip(b[[0, 2]], 0, w) # clip boxes outside of image\n b[[1, 3]] = np.clip(b[[1, 3]], 0, h)\n assert cv2.imwrite(str(f), im[b[1]:b[3], b[0]:b[2]]), f'box failure in {f}'\n\n\ndef autosplit(path='../coco128', weights=(0.9, 0.1, 0.0)): # from utils.datasets import *; autosplit('../coco128')\n \"\"\" Autosplit a dataset into train/val/test splits and save path/autosplit_*.txt files\n # Arguments\n path: Path to images directory\n weights: Train, val, test weights (list)\n \"\"\"\n path = Path(path) # images dir\n files = list(path.rglob('*.*'))\n n = len(files) # number of files\n indices = random.choices([0, 1, 2], weights=weights, k=n) # assign each image to a split\n txt = ['autosplit_train.txt', 'autosplit_val.txt', 'autosplit_test.txt'] # 3 txt files\n [(path / x).unlink() for x in txt if (path / x).exists()] # remove existing\n for i, img in tqdm(zip(indices, files), total=n):\n if img.suffix[1:] in img_formats:\n with open(path / txt[i], 'a') as f:\n f.write(str(img) + '\\n') # add image to txt file\n"
] | [
[
"numpy.array",
"pandas.DataFrame",
"numpy.float32",
"numpy.frombuffer",
"pandas.read_csv"
],
[
"torch.cat",
"torch.stack",
"numpy.minimum",
"torch.load",
"numpy.concatenate",
"numpy.full",
"numpy.eye",
"numpy.flipud",
"numpy.arange",
"torch.tensor",
"numpy.append",
"numpy.mod",
"torch.zeros",
"numpy.array",
"numpy.zeros",
"torch.save",
"numpy.stack",
"numpy.clip",
"numpy.fliplr",
"numpy.ascontiguousarray",
"numpy.ones",
"torch.from_numpy",
"numpy.random.beta",
"numpy.random.uniform",
"torch.utils.data.distributed.DistributedSampler",
"numpy.unique",
"numpy.maximum"
]
] |
phanvanthinh98/keras_LSTM | [
"b22cff1e9fd762226ec3dc9d3af3e300484dd833",
"2d551d31915906120f3f6a3ed3c4de94ba4bb288"
] | [
"keras/wrappers/scikit_learn.py",
"keras/distribute/custom_training_loop_optimizer_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\"\"\"Wrapper for using the Scikit-Learn API with Keras models.\"\"\"\n# pylint: disable=g-classes-have-attributes\n\nimport copy\nimport types\n\nimport numpy as np\n\nfrom keras import losses\nfrom keras.models import Sequential\nfrom keras.utils.generic_utils import has_arg\nfrom keras.utils.np_utils import to_categorical\nfrom tensorflow.python.util.tf_export import keras_export\n\n\nclass BaseWrapper(object):\n \"\"\"Base class for the Keras scikit-learn wrapper.\n\n Warning: This class should not be used directly.\n Use descendant classes instead.\n\n Args:\n build_fn: callable function or class instance\n **sk_params: model parameters & fitting parameters\n\n The `build_fn` should construct, compile and return a Keras model, which\n will then be used to fit/predict. One of the following\n three values could be passed to `build_fn`:\n 1. A function\n 2. An instance of a class that implements the `__call__` method\n 3. None. This means you implement a class that inherits from either\n `KerasClassifier` or `KerasRegressor`. The `__call__` method of the\n present class will then be treated as the default `build_fn`.\n\n `sk_params` takes both model parameters and fitting parameters. Legal model\n parameters are the arguments of `build_fn`. Note that like all other\n estimators in scikit-learn, `build_fn` should provide default values for\n its arguments, so that you could create the estimator without passing any\n values to `sk_params`.\n\n `sk_params` could also accept parameters for calling `fit`, `predict`,\n `predict_proba`, and `score` methods (e.g., `epochs`, `batch_size`).\n fitting (predicting) parameters are selected in the following order:\n\n 1. Values passed to the dictionary arguments of\n `fit`, `predict`, `predict_proba`, and `score` methods\n 2. Values passed to `sk_params`\n 3. The default values of the `keras.models.Sequential`\n `fit`, `predict`, `predict_proba` and `score` methods\n\n When using scikit-learn's `grid_search` API, legal tunable parameters are\n those you could pass to `sk_params`, including fitting parameters.\n In other words, you could use `grid_search` to search for the best\n `batch_size` or `epochs` as well as the model parameters.\n \"\"\"\n\n def __init__(self, build_fn=None, **sk_params):\n self.build_fn = build_fn\n self.sk_params = sk_params\n self.check_params(sk_params)\n\n def check_params(self, params):\n \"\"\"Checks for user typos in `params`.\n\n Args:\n params: dictionary; the parameters to be checked\n\n Raises:\n ValueError: if any member of `params` is not a valid argument.\n \"\"\"\n legal_params_fns = [\n Sequential.fit, Sequential.predict, Sequential.predict_classes,\n Sequential.evaluate\n ]\n if self.build_fn is None:\n legal_params_fns.append(self.__call__)\n elif (not isinstance(self.build_fn, types.FunctionType) and\n not isinstance(self.build_fn, types.MethodType)):\n legal_params_fns.append(self.build_fn.__call__)\n else:\n legal_params_fns.append(self.build_fn)\n\n for params_name in params:\n for fn in legal_params_fns:\n if has_arg(fn, params_name):\n break\n else:\n if params_name != 'nb_epoch':\n raise ValueError('{} is not a legal parameter'.format(params_name))\n\n def get_params(self, **params): # pylint: disable=unused-argument\n \"\"\"Gets parameters for this estimator.\n\n Args:\n **params: ignored (exists for API compatibility).\n\n Returns:\n Dictionary of parameter names mapped to their values.\n \"\"\"\n res = self.sk_params.copy()\n res.update({'build_fn': self.build_fn})\n return res\n\n def set_params(self, **params):\n \"\"\"Sets the parameters of this estimator.\n\n Args:\n **params: Dictionary of parameter names mapped to their values.\n\n Returns:\n self\n \"\"\"\n self.check_params(params)\n self.sk_params.update(params)\n return self\n\n def fit(self, x, y, **kwargs):\n \"\"\"Constructs a new model with `build_fn` & fit the model to `(x, y)`.\n\n Args:\n x : array-like, shape `(n_samples, n_features)`\n Training samples where `n_samples` is the number of samples\n and `n_features` is the number of features.\n y : array-like, shape `(n_samples,)` or `(n_samples, n_outputs)`\n True labels for `x`.\n **kwargs: dictionary arguments\n Legal arguments are the arguments of `Sequential.fit`\n\n Returns:\n history : object\n details about the training history at each epoch.\n \"\"\"\n if self.build_fn is None:\n self.model = self.__call__(**self.filter_sk_params(self.__call__))\n elif (not isinstance(self.build_fn, types.FunctionType) and\n not isinstance(self.build_fn, types.MethodType)):\n self.model = self.build_fn(\n **self.filter_sk_params(self.build_fn.__call__))\n else:\n self.model = self.build_fn(**self.filter_sk_params(self.build_fn))\n\n if (losses.is_categorical_crossentropy(self.model.loss) and\n len(y.shape) != 2):\n y = to_categorical(y)\n\n fit_args = copy.deepcopy(self.filter_sk_params(Sequential.fit))\n fit_args.update(kwargs)\n\n history = self.model.fit(x, y, **fit_args)\n\n return history\n\n def filter_sk_params(self, fn, override=None):\n \"\"\"Filters `sk_params` and returns those in `fn`'s arguments.\n\n Args:\n fn : arbitrary function\n override: dictionary, values to override `sk_params`\n\n Returns:\n res : dictionary containing variables\n in both `sk_params` and `fn`'s arguments.\n \"\"\"\n override = override or {}\n res = {}\n for name, value in self.sk_params.items():\n if has_arg(fn, name):\n res.update({name: value})\n res.update(override)\n return res\n\n\n@keras_export('keras.wrappers.scikit_learn.KerasClassifier')\nclass KerasClassifier(BaseWrapper):\n \"\"\"Implementation of the scikit-learn classifier API for Keras.\n \"\"\"\n\n def fit(self, x, y, **kwargs):\n \"\"\"Constructs a new model with `build_fn` & fit the model to `(x, y)`.\n\n Args:\n x : array-like, shape `(n_samples, n_features)`\n Training samples where `n_samples` is the number of samples\n and `n_features` is the number of features.\n y : array-like, shape `(n_samples,)` or `(n_samples, n_outputs)`\n True labels for `x`.\n **kwargs: dictionary arguments\n Legal arguments are the arguments of `Sequential.fit`\n\n Returns:\n history : object\n details about the training history at each epoch.\n\n Raises:\n ValueError: In case of invalid shape for `y` argument.\n \"\"\"\n y = np.array(y)\n if len(y.shape) == 2 and y.shape[1] > 1:\n self.classes_ = np.arange(y.shape[1])\n elif (len(y.shape) == 2 and y.shape[1] == 1) or len(y.shape) == 1:\n self.classes_ = np.unique(y)\n y = np.searchsorted(self.classes_, y)\n else:\n raise ValueError('Invalid shape for y: ' + str(y.shape))\n self.n_classes_ = len(self.classes_)\n return super(KerasClassifier, self).fit(x, y, **kwargs)\n\n def predict(self, x, **kwargs):\n \"\"\"Returns the class predictions for the given test data.\n\n Args:\n x: array-like, shape `(n_samples, n_features)`\n Test samples where `n_samples` is the number of samples\n and `n_features` is the number of features.\n **kwargs: dictionary arguments\n Legal arguments are the arguments\n of `Sequential.predict_classes`.\n\n Returns:\n preds: array-like, shape `(n_samples,)`\n Class predictions.\n \"\"\"\n kwargs = self.filter_sk_params(Sequential.predict_classes, kwargs)\n classes = self.model.predict_classes(x, **kwargs)\n return self.classes_[classes]\n\n def predict_proba(self, x, **kwargs):\n \"\"\"Returns class probability estimates for the given test data.\n\n Args:\n x: array-like, shape `(n_samples, n_features)`\n Test samples where `n_samples` is the number of samples\n and `n_features` is the number of features.\n **kwargs: dictionary arguments\n Legal arguments are the arguments\n of `Sequential.predict_classes`.\n\n Returns:\n proba: array-like, shape `(n_samples, n_outputs)`\n Class probability estimates.\n In the case of binary classification,\n to match the scikit-learn API,\n will return an array of shape `(n_samples, 2)`\n (instead of `(n_sample, 1)` as in Keras).\n \"\"\"\n kwargs = self.filter_sk_params(Sequential.predict_proba, kwargs)\n probs = self.model.predict(x, **kwargs)\n\n # check if binary classification\n if probs.shape[1] == 1:\n # first column is probability of class 0 and second is of class 1\n probs = np.hstack([1 - probs, probs])\n return probs\n\n def score(self, x, y, **kwargs):\n \"\"\"Returns the mean accuracy on the given test data and labels.\n\n Args:\n x: array-like, shape `(n_samples, n_features)`\n Test samples where `n_samples` is the number of samples\n and `n_features` is the number of features.\n y: array-like, shape `(n_samples,)` or `(n_samples, n_outputs)`\n True labels for `x`.\n **kwargs: dictionary arguments\n Legal arguments are the arguments of `Sequential.evaluate`.\n\n Returns:\n score: float\n Mean accuracy of predictions on `x` wrt. `y`.\n\n Raises:\n ValueError: If the underlying model isn't configured to\n compute accuracy. You should pass `metrics=[\"accuracy\"]` to\n the `.compile()` method of the model.\n \"\"\"\n y = np.searchsorted(self.classes_, y)\n kwargs = self.filter_sk_params(Sequential.evaluate, kwargs)\n\n loss_name = self.model.loss\n if hasattr(loss_name, '__name__'):\n loss_name = loss_name.__name__\n if loss_name == 'categorical_crossentropy' and len(y.shape) != 2:\n y = to_categorical(y)\n\n outputs = self.model.evaluate(x, y, **kwargs)\n if not isinstance(outputs, list):\n outputs = [outputs]\n for name, output in zip(self.model.metrics_names, outputs):\n if name in ['accuracy', 'acc']:\n return output\n raise ValueError('The model is not configured to compute accuracy. '\n 'You should pass `metrics=[\"accuracy\"]` to '\n 'the `model.compile()` method.')\n\n\n@keras_export('keras.wrappers.scikit_learn.KerasRegressor')\nclass KerasRegressor(BaseWrapper):\n \"\"\"Implementation of the scikit-learn regressor API for Keras.\n \"\"\"\n\n def predict(self, x, **kwargs):\n \"\"\"Returns predictions for the given test data.\n\n Args:\n x: array-like, shape `(n_samples, n_features)`\n Test samples where `n_samples` is the number of samples\n and `n_features` is the number of features.\n **kwargs: dictionary arguments\n Legal arguments are the arguments of `Sequential.predict`.\n\n Returns:\n preds: array-like, shape `(n_samples,)`\n Predictions.\n \"\"\"\n kwargs = self.filter_sk_params(Sequential.predict, kwargs)\n return np.squeeze(self.model.predict(x, **kwargs))\n\n def score(self, x, y, **kwargs):\n \"\"\"Returns the mean loss on the given test data and labels.\n\n Args:\n x: array-like, shape `(n_samples, n_features)`\n Test samples where `n_samples` is the number of samples\n and `n_features` is the number of features.\n y: array-like, shape `(n_samples,)`\n True labels for `x`.\n **kwargs: dictionary arguments\n Legal arguments are the arguments of `Sequential.evaluate`.\n\n Returns:\n score: float\n Mean accuracy of predictions on `x` wrt. `y`.\n \"\"\"\n kwargs = self.filter_sk_params(Sequential.evaluate, kwargs)\n loss = self.model.evaluate(x, y, **kwargs)\n if isinstance(loss, list):\n return -loss[0]\n return -loss\n",
"# Copyright 2019 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 custom training loops that involves advanced optimizer usage.\"\"\"\n\nimport tensorflow.compat.v2 as tf\n\nfrom absl.testing import parameterized\nfrom tensorflow.python.distribute import values\nfrom keras.distribute import strategy_combinations as keras_strategy_combinations\nfrom keras.optimizer_v2 import gradient_descent\n\n\nclass OptimizerTest(tf.test.TestCase, parameterized.TestCase):\n\n @tf.__internal__.distribute.combinations.generate(\n tf.__internal__.test.combinations.times(\n tf.__internal__.test.combinations.combine(\n distribution=keras_strategy_combinations.multidevice_strategies,\n mode=[\"eager\"],\n ),\n tf.__internal__.test.combinations.combine(\n experimental_aggregate_gradients=True,\n expected=[[[-0.3, -0.3], [-0.3, -0.3]]]) +\n tf.__internal__.test.combinations.combine(\n experimental_aggregate_gradients=False,\n expected=[[[-0.1, -0.1], [-0.2, -0.2]]])\n ))\n def test_custom_aggregation(self, distribution,\n experimental_aggregate_gradients, expected):\n\n with distribution.scope():\n v = tf.Variable([0., 0.])\n optimizer = gradient_descent.SGD(0.1)\n\n class PerReplica(values.DistributedValues):\n \"\"\"Holds a map from replica to unsynchronized values.\"\"\"\n\n @property\n def values(self):\n \"\"\"Returns the per replica values.\"\"\"\n return self._values\n\n @tf.function\n def optimize():\n with tf.compat.v1.device(distribution.extended.worker_devices[0]):\n v1 = tf.convert_to_tensor([1., 1.])\n with tf.compat.v1.device(distribution.extended.worker_devices[1]):\n v2 = tf.convert_to_tensor([2., 2.])\n grads = PerReplica([v1, v2])\n def step_fn(grads):\n optimizer.apply_gradients(\n [(grads, v)],\n experimental_aggregate_gradients=experimental_aggregate_gradients)\n return v.read_value()\n\n return distribution.experimental_local_results(\n distribution.run(step_fn, args=(grads,)))\n\n self.assertAllClose(optimize(), expected)\n\n @tf.__internal__.distribute.combinations.generate(\n tf.__internal__.test.combinations.combine(\n distribution=tf.__internal__.distribute.combinations.one_device_strategy,\n mode=[\"eager\"],\n experimental_aggregate_gradients=[True, False]))\n def test_custom_aggregation_one_device(self, distribution,\n experimental_aggregate_gradients):\n\n with distribution.scope():\n v = tf.Variable([0., 0.])\n optimizer = gradient_descent.SGD(0.1)\n\n @tf.function\n def optimize():\n grads = tf.convert_to_tensor([1., 1.])\n\n def step_fn(grads):\n optimizer.apply_gradients(\n [(grads, v)],\n experimental_aggregate_gradients=experimental_aggregate_gradients)\n return v.read_value()\n\n return distribution.experimental_local_results(\n distribution.run(step_fn, args=(grads,)))\n\n self.assertAllClose(optimize(), [[-0.1, -0.1]])\n\n @tf.__internal__.distribute.combinations.generate(\n tf.__internal__.test.combinations.combine(distribution=[\n tf.__internal__.distribute.combinations.central_storage_strategy_with_gpu_and_cpu\n ]))\n def test_custom_aggregation_central_storage(self, distribution):\n with distribution.scope():\n v = tf.Variable([0., 0.])\n optimizer = gradient_descent.SGD(0.1)\n\n grads = tf.convert_to_tensor([1., 1.])\n\n def step_fn(grads):\n with self.assertRaises(NotImplementedError):\n optimizer.apply_gradients([(grads, v)],\n experimental_aggregate_gradients=False)\n\n return distribution.run(step_fn, args=(grads,))\n\n\nif __name__ == \"__main__\":\n tf.test.main()\n"
] | [
[
"numpy.array",
"tensorflow.python.util.tf_export.keras_export",
"numpy.hstack",
"numpy.arange",
"numpy.searchsorted",
"numpy.unique"
],
[
"tensorflow.compat.v2.test.main",
"tensorflow.compat.v2.compat.v1.device",
"tensorflow.compat.v2.Variable",
"tensorflow.compat.v2.convert_to_tensor",
"tensorflow.compat.v2.__internal__.test.combinations.combine"
]
] |
daniil-lyakhov/deep-object-reid | [
"b0f7d6a2d4cff8c417a66d82c09d16788d81ec67",
"b0f7d6a2d4cff8c417a66d82c09d16788d81ec67"
] | [
"torchreid/models/mobilenetv3.py",
"torchreid/engine/image/multilabel.py"
] | [
"import math\n\nimport torch\nimport torch.nn as nn\nfrom torch.cuda.amp import autocast\n\nfrom torchreid.losses import AngleSimpleLinear\nfrom torchreid.ops import Dropout, EvalModeSetter, rsc\nfrom .common import HSigmoid, HSwish, ModelInterface, make_divisible\nimport timm\n\nfrom torchreid.integration.nncf.compression import get_no_nncf_trace_context_manager, nullcontext\n\n__all__ = ['mobilenetv3_large', 'mobilenetv3_large_075', 'mobilenetv3_small', 'mobilenetv3_large_150',\n 'mobilenetv3_large_125']\n\npretrained_urls = {\n 'mobilenetv3_small':\n 'https://github.com/d-li14/mobilenetv3.pytorch/blob/master/pretrained/mobilenetv3-small-55df8e1f.pth?raw=true',\n 'mobilenetv3_large':\n 'https://github.com/d-li14/mobilenetv3.pytorch/blob/master/pretrained/mobilenetv3-large-1cd25616.pth?raw=true',\n 'mobilenetv3_large_075':\n 'https://github.com/d-li14/mobilenetv3.pytorch/blob/master/pretrained/mobilenetv3-large-0.75-9632d2a8.pth?raw=true',\n 'mobilenetv3_large_21k':\n 'https://miil-public-eu.oss-eu-central-1.aliyuncs.com/model-zoo/ImageNet_21K_P/models/mobilenetv3_large_100_miil_21k.pth'\n}\n\n\nSHOULD_NNCF_SKIP_SE_LAYERS = False\nSHOULD_NNCF_SKIP_HEAD = False\nno_nncf_se_layer_context = get_no_nncf_trace_context_manager() if SHOULD_NNCF_SKIP_SE_LAYERS else nullcontext\nno_nncf_head_context = get_no_nncf_trace_context_manager() if SHOULD_NNCF_SKIP_HEAD else nullcontext\n\nclass SELayer(nn.Module):\n def __init__(self, channel, reduction=4):\n super(SELayer, self).__init__()\n self.avg_pool = nn.AdaptiveAvgPool2d(1)\n self.fc = nn.Sequential(\n nn.Linear(channel, make_divisible(channel // reduction, 8)),\n nn.ReLU(inplace=True),\n nn.Linear(make_divisible(channel // reduction, 8), channel),\n HSigmoid()\n )\n\n def forward(self, x):\n with no_nncf_se_layer_context():\n b, c, _, _ = x.size()\n y = self.avg_pool(x).view(b, c)\n y = self.fc(y).view(b, c, 1, 1)\n return x * y\n\n\ndef conv_3x3_bn(inp, oup, stride, IN_conv1=False):\n return nn.Sequential(\n nn.Conv2d(inp, oup, 3, stride, 1, bias=False),\n nn.BatchNorm2d(oup) if not IN_conv1 else nn.InstanceNorm2d(oup, affine=True),\n HSwish()\n )\n\n\ndef conv_1x1_bn(inp, oup, loss='softmax'):\n return nn.Sequential(\n nn.Conv2d(inp, oup, 1, 1, 0, bias=False),\n nn.BatchNorm2d(oup),\n HSwish() if loss == 'softmax' else nn.PReLU()\n )\n\n\nclass InvertedResidual(nn.Module):\n def __init__(self, inp, hidden_dim, oup, kernel_size, stride, use_se, use_hs):\n super(InvertedResidual, self).__init__()\n assert stride in [1, 2]\n\n self.identity = stride == 1 and inp == oup\n\n if inp == hidden_dim:\n self.conv = nn.Sequential(\n # dw\n nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim, bias=False),\n nn.BatchNorm2d(hidden_dim),\n HSwish() if use_hs else nn.ReLU(inplace=True),\n # Squeeze-and-Excite\n SELayer(hidden_dim) if use_se else nn.Identity(),\n # pw-linear\n nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),\n nn.BatchNorm2d(oup),\n )\n else:\n self.conv = nn.Sequential(\n # pw\n nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),\n nn.BatchNorm2d(hidden_dim),\n HSwish() if use_hs else nn.ReLU(inplace=True),\n # dw\n nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim, bias=False),\n nn.BatchNorm2d(hidden_dim),\n # Squeeze-and-Excite\n SELayer(hidden_dim) if use_se else nn.Identity(),\n HSwish() if use_hs else nn.ReLU(inplace=True),\n # pw-linear\n nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),\n nn.BatchNorm2d(oup),\n )\n\n def forward(self, x):\n if self.identity:\n return x + self.conv(x)\n else:\n return self.conv(x)\n\n\nclass MobileNetV3(ModelInterface):\n def __init__(self,\n cfgs,\n mode,\n IN_conv1=False,\n num_classes=1000,\n width_mult=1.,\n in_channels=3,\n input_size=(224, 224),\n dropout_cls = None,\n pooling_type='avg',\n IN_first=False,\n self_challenging_cfg=False,\n **kwargs):\n\n super().__init__(**kwargs)\n self.in_size = input_size\n self.num_classes = num_classes\n self.input_IN = nn.InstanceNorm2d(in_channels, affine=True) if IN_first else None\n self.pooling_type = pooling_type\n self.self_challenging_cfg = self_challenging_cfg\n self.width_mult = width_mult\n self.dropout_cls = dropout_cls\n # setting of inverted residual blocks\n self.cfgs = cfgs\n assert mode in ['large', 'small']\n # building first layer\n input_channel = make_divisible(16 * self.width_mult, 8)\n stride = 1 if self.in_size[0] < 100 else 2\n layers = [conv_3x3_bn(3, input_channel, stride, IN_conv1)]\n # building inverted residual blocks\n block = InvertedResidual\n flag = True\n for k, t, c, use_se, use_hs, s in self.cfgs:\n if (self.in_size[0] < 100) and (s == 2) and flag:\n s = 1\n flag = False\n output_channel = make_divisible(c * self.width_mult, 8)\n exp_size = make_divisible(input_channel * t, 8)\n layers.append(block(input_channel, exp_size, output_channel, k, s, use_se, use_hs))\n input_channel = output_channel\n self.features = nn.Sequential(*layers)\n self.num_features = exp_size\n # building last several layers\n self.conv = conv_1x1_bn(input_channel, exp_size, self.loss)\n output_channel = {'large': 1280, 'small': 1024}\n output_channel = make_divisible(output_channel[mode] * self.width_mult, 8) if self.width_mult > 1.0 else output_channel[mode]\n\n if self.loss == 'softmax' or self.loss == 'asl':\n self.classifier = nn.Sequential(\n nn.Linear(exp_size, output_channel),\n nn.BatchNorm1d(output_channel),\n HSwish(),\n Dropout(**self.dropout_cls),\n nn.Linear(output_channel, self.num_classes),\n )\n else:\n assert self.loss in ['am_softmax', 'am_binary']\n self.classifier = nn.Sequential(\n nn.Linear(exp_size, output_channel),\n nn.BatchNorm1d(output_channel),\n nn.PReLU(),\n Dropout(**self.dropout_cls),\n AngleSimpleLinear(output_channel, self.num_classes),\n )\n self._initialize_weights()\n self.forward = autocast(self.mix_precision)(self.forward)\n\n def extract_features(self, x):\n y = self.conv(self.features(x))\n return y\n\n def infer_head(self, x, skip_pool=False):\n if not skip_pool:\n glob_features = self._glob_feature_vector(x, self.pooling_type, reduce_dims=False)\n else:\n glob_features = x\n\n logits = self.classifier(glob_features.view(x.shape[0], -1))\n return glob_features, logits\n\n def _initialize_weights(self):\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n m.weight.data.normal_(0, math.sqrt(2. / n))\n if m.bias is not None:\n m.bias.data.zero_()\n elif isinstance(m, nn.BatchNorm2d):\n m.weight.data.fill_(1)\n m.bias.data.zero_()\n elif isinstance(m, nn.Linear):\n n = m.weight.size(1)\n m.weight.data.normal_(0, 0.01)\n m.bias.data.zero_()\n\n def forward(self, x, return_featuremaps=False, get_embeddings=False, gt_labels=None):\n if self.input_IN is not None:\n x = self.input_IN(x)\n\n y = self.extract_features(x)\n if return_featuremaps:\n return y\n\n with no_nncf_head_context():\n glob_features, logits = self.infer_head(y, skip_pool=False)\n if self.training and self.self_challenging_cfg.enable and gt_labels is not None:\n glob_features = rsc(\n features = glob_features,\n scores = logits,\n labels = gt_labels,\n retain_p = 1.0 - self.self_challenging_cfg.drop_p,\n retain_batch = 1.0 - self.self_challenging_cfg.drop_batch_p\n )\n\n with EvalModeSetter([self.output], m_type=(nn.BatchNorm1d, nn.BatchNorm2d)):\n _, logits = self.infer_head(x, skip_pool=True)\n\n if not self.training and self.is_classification():\n return [logits]\n\n if get_embeddings:\n out_data = [logits, glob_features]\n elif self.loss in ['softmax', 'am_softmax', 'asl', 'am_binary']:\n out_data = [logits]\n elif self.loss in ['triplet']:\n out_data = [logits, glob_features]\n else:\n raise KeyError(\"Unsupported loss: {}\".format(self.loss))\n\n return tuple(out_data)\n\n\ndef init_pretrained_weights(model, key='', **kwargs):\n \"\"\"Initializes model with pretrained weights.\n Layers that don't match with pretrained layers in name or size are kept unchanged.\n \"\"\"\n import os\n import errno\n import gdown\n\n from torchreid.utils import load_pretrained_weights\n\n def _get_torch_home():\n ENV_TORCH_HOME = 'TORCH_HOME'\n ENV_XDG_CACHE_HOME = 'XDG_CACHE_HOME'\n DEFAULT_CACHE_DIR = '~/.cache'\n torch_home = os.path.expanduser(\n os.getenv(\n ENV_TORCH_HOME,\n os.path.join(\n os.getenv(ENV_XDG_CACHE_HOME, DEFAULT_CACHE_DIR), 'torch'\n )\n )\n )\n return torch_home\n\n torch_home = _get_torch_home()\n model_dir = os.path.join(torch_home, 'checkpoints')\n try:\n os.makedirs(model_dir)\n except OSError as e:\n if e.errno == errno.EEXIST:\n pass\n else:\n raise\n filename = key + '_imagenet.pth'\n cached_file = os.path.join(model_dir, filename)\n if not os.path.exists(cached_file):\n gdown.download(pretrained_urls[key], cached_file)\n model = load_pretrained_weights(model, cached_file, **kwargs)\n\n\ndef mobilenetv3_large_075(pretrained=False, **kwargs):\n \"\"\"\n Constructs a MobileNetV3-Large model\n \"\"\"\n cfgs = [\n # k, t, c, SE, HS, s\n [3, 1, 16, 0, 0, 1],\n [3, 4, 24, 0, 0, 2],\n [3, 3, 24, 0, 0, 1],\n [5, 3, 40, 1, 0, 2],\n [5, 3, 40, 1, 0, 1],\n [5, 3, 40, 1, 0, 1],\n [3, 6, 80, 0, 1, 2],\n [3, 2.5, 80, 0, 1, 1],\n [3, 2.3, 80, 0, 1, 1],\n [3, 2.3, 80, 0, 1, 1],\n [3, 6, 112, 1, 1, 1],\n [3, 6, 112, 1, 1, 1],\n [5, 6, 160, 1, 1, 2],\n [5, 6, 160, 1, 1, 1],\n [5, 6, 160, 1, 1, 1]\n ]\n\n net = MobileNetV3(cfgs, mode='large', width_mult =.75, **kwargs)\n if pretrained:\n init_pretrained_weights(net, key='mobilenetv3_large_075')\n\n return net\n\n\ndef mobilenetv3_large(pretrained=False, **kwargs):\n \"\"\"\n Constructs a MobileNetV3-Large model\n \"\"\"\n cfgs = [\n # k, t, c, SE, HS, s\n [3, 1, 16, 0, 0, 1],\n [3, 4, 24, 0, 0, 2],\n [3, 3, 24, 0, 0, 1],\n [5, 3, 40, 1, 0, 2],\n [5, 3, 40, 1, 0, 1],\n [5, 3, 40, 1, 0, 1],\n [3, 6, 80, 0, 1, 2],\n [3, 2.5, 80, 0, 1, 1],\n [3, 2.3, 80, 0, 1, 1],\n [3, 2.3, 80, 0, 1, 1],\n [3, 6, 112, 1, 1, 1],\n [3, 6, 112, 1, 1, 1],\n [5, 6, 160, 1, 1, 2],\n [5, 6, 160, 1, 1, 1],\n [5, 6, 160, 1, 1, 1]\n ]\n\n net = MobileNetV3(cfgs, mode='large', width_mult = 1., **kwargs)\n if pretrained:\n init_pretrained_weights(net, key='mobilenetv3_large')\n\n return net\n\n\ndef mobilenetv3_large_150(pretrained=False, **kwargs):\n \"\"\"\n Constructs a MobileNetV3-Large model\n \"\"\"\n cfgs = [\n # k, t, c, SE, HS, s\n [3, 1, 16, 0, 0, 1],\n [3, 4, 24, 0, 0, 2],\n [3, 3, 24, 0, 0, 1],\n [5, 3, 40, 1, 0, 2],\n [5, 3, 40, 1, 0, 1],\n [5, 3, 40, 1, 0, 1],\n [3, 6, 80, 0, 1, 2],\n [3, 2.5, 80, 0, 1, 1],\n [3, 2.3, 80, 0, 1, 1],\n [3, 2.3, 80, 0, 1, 1],\n [3, 6, 112, 1, 1, 1],\n [3, 6, 112, 1, 1, 1],\n [5, 6, 160, 1, 1, 2],\n [5, 6, 160, 1, 1, 1],\n [5, 6, 160, 1, 1, 1]\n ]\n\n net = MobileNetV3(cfgs, mode='large', width_mult = 1.5, **kwargs)\n if pretrained:\n raise NotImplementedError(\"The weights for this configuration are not available\")\n\n return net\n\n\ndef mobilenetv3_large_125(pretrained=False, **kwargs):\n \"\"\"\n Constructs a MobileNetV3-Large model\n \"\"\"\n cfgs = [\n # k, t, c, SE, HS, s\n [3, 1, 16, 0, 0, 1],\n [3, 4, 24, 0, 0, 2],\n [3, 3, 24, 0, 0, 1],\n [5, 3, 40, 1, 0, 2],\n [5, 3, 40, 1, 0, 1],\n [5, 3, 40, 1, 0, 1],\n [3, 6, 80, 0, 1, 2],\n [3, 2.5, 80, 0, 1, 1],\n [3, 2.3, 80, 0, 1, 1],\n [3, 2.3, 80, 0, 1, 1],\n [3, 6, 112, 1, 1, 1],\n [3, 6, 112, 1, 1, 1],\n [5, 6, 160, 1, 1, 2],\n [5, 6, 160, 1, 1, 1],\n [5, 6, 160, 1, 1, 1]\n ]\n\n net = MobileNetV3(cfgs, mode='large', width_mult = 1.25, **kwargs)\n if pretrained:\n raise NotImplementedError(\"The weights for this configuration are not available\")\n\n return net\n\n\ndef mobilenetv3_small(pretrained=False, **kwargs):\n \"\"\"\n Constructs a MobileNetV3-Small model\n \"\"\"\n cfgs = [\n # k, t, c, SE, HS, s\n [3, 1, 16, 1, 0, 2],\n [3, 4.5, 24, 0, 0, 2],\n [3, 3.67, 24, 0, 0, 1],\n [5, 4, 40, 1, 1, 2],\n [5, 6, 40, 1, 1, 1],\n [5, 6, 40, 1, 1, 1],\n [5, 3, 48, 1, 1, 1],\n [5, 3, 48, 1, 1, 1],\n [5, 6, 96, 1, 1, 2],\n [5, 6, 96, 1, 1, 1],\n [5, 6, 96, 1, 1, 1],\n ]\n net = MobileNetV3(cfgs, mode='small', width_mult = 1., **kwargs)\n if pretrained:\n init_pretrained_weights(net, key='mobilenetv3_small')\n\n return net\n",
"from __future__ import absolute_import, division, print_function\nfrom enum import auto\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom torch.cuda.amp import GradScaler, autocast\n\nfrom torchreid import metrics\nfrom torchreid.losses import AsymmetricLoss, AMBinaryLoss\nfrom torchreid.metrics.accuracy import accuracy\nfrom torchreid.optim import SAM\nfrom ..engine import Engine\n\nclass MultilabelEngine(Engine):\n r\"\"\"Multilabel classification engine. It supports ASL, BCE and Angular margin loss with binary classification.\"\"\"\n def __init__(self, datamanager, models, optimizers, schedulers, use_gpu, save_all_chkpts,\n train_patience, early_stoping, lr_decay_factor, loss_name, label_smooth,\n lr_finder, m, s, sym_adjustment, auto_balance, amb_k, amb_t, clip_grad,\n should_freeze_aux_models, nncf_metainfo, initial_lr,\n target_metric, use_ema_decay, ema_decay, asl_gamma_pos, asl_gamma_neg, asl_p_m,\n mix_precision, **kwargs):\n\n super().__init__(datamanager,\n models=models,\n optimizers=optimizers,\n schedulers=schedulers,\n use_gpu=use_gpu,\n save_all_chkpts=save_all_chkpts,\n train_patience=train_patience,\n lr_decay_factor=lr_decay_factor,\n early_stoping=early_stoping,\n should_freeze_aux_models=should_freeze_aux_models,\n nncf_metainfo=nncf_metainfo,\n initial_lr=initial_lr,\n lr_finder=lr_finder,\n target_metric=target_metric,\n use_ema_decay=use_ema_decay,\n ema_decay=ema_decay)\n\n self.main_losses = nn.ModuleList()\n self.clip_grad = clip_grad\n num_classes = self.datamanager.num_train_pids\n if not isinstance(num_classes, (list, tuple)):\n num_classes = [num_classes]\n self.num_classes = num_classes\n\n for _ in enumerate(self.num_classes):\n if loss_name == 'asl':\n self.main_losses.append(AsymmetricLoss(\n gamma_neg=asl_gamma_neg,\n gamma_pos=asl_gamma_pos,\n probability_margin=asl_p_m,\n label_smooth=label_smooth,\n ))\n elif loss_name == 'bce':\n self.main_losses.append(AsymmetricLoss(\n gamma_neg=0,\n gamma_pos=0,\n probability_margin=0,\n label_smooth=label_smooth,\n ))\n elif loss_name == 'am_binary':\n self.main_losses.append(AMBinaryLoss(\n m=m,\n k=amb_k,\n t=amb_t,\n s=s,\n sym_adjustment=sym_adjustment,\n auto_balance=auto_balance,\n gamma_neg=asl_gamma_neg,\n gamma_pos=asl_gamma_pos,\n label_smooth=label_smooth,\n ))\n\n num_classes = self.datamanager.num_train_pids\n if not isinstance(num_classes, (list, tuple)):\n num_classes = [num_classes]\n self.num_classes = num_classes\n self.num_targets = len(self.num_classes)\n self.enable_sam = isinstance(self.optims[self.main_model_name], SAM)\n\n for model_name in self.get_model_names():\n assert isinstance(self.optims[model_name], SAM) == self.enable_sam, \"SAM must be enabled \\\n for all models or none of them\"\n self.scaler = GradScaler(enabled=mix_precision)\n self.prev_smooth_top1 = 0.\n self.forward_backward = autocast(mix_precision)(self.forward_backward)\n\n def forward_backward(self, data):\n n_iter = self.epoch * self.num_batches + self.batch_idx\n\n train_records = self.parse_data_for_train(data, output_dict=True, use_gpu=self.use_gpu)\n imgs, obj_ids = train_records['img'], train_records['obj_id']\n\n model_names = self.get_model_names()\n num_models = len(model_names)\n steps = [1,2] if self.enable_sam and not self.lr_finder else [1]\n # forward pass\n for step in steps:\n # if sam is enabled then statistics will be written each step, but will be saved only the second time\n # this is made just for convinience\n avg_acc = 0.0\n out_logits = [[] for _ in range(self.num_targets)]\n total_loss = torch.zeros([], dtype=imgs.dtype, device=imgs.device)\n loss_summary = dict()\n\n for model_name in model_names:\n self.optims[model_name].zero_grad()\n model_loss, model_loss_summary, model_avg_acc, model_logits = self._single_model_losses(\n self.models[model_name], train_records, imgs, obj_ids, n_iter, model_name)\n avg_acc += model_avg_acc / float(num_models)\n total_loss += model_loss / float(num_models)\n loss_summary.update(model_loss_summary)\n\n for trg_id in range(self.num_targets):\n if model_logits[trg_id] is not None:\n out_logits[trg_id].append(model_logits[trg_id])\n model_num = len(model_names)\n # compute mutual loss\n if len(model_names) > 1:\n mutual_loss = torch.zeros([], dtype=imgs.dtype, device=imgs.device)\n for trg_id in range(self.num_targets):\n if len(out_logits[trg_id]) <= 1:\n continue\n for model_i, logits_i in enumerate(out_logits[trg_id]):\n probabilities_i = torch.sigmoid(logits_i)\n kl_loss = 0\n for model_j, logits_j in enumerate(out_logits[trg_id]):\n if model_i != model_j:\n probabilities_j = torch.sigmoid(logits_j)\n kl_loss += self.kl_div_binary(probabilities_i, probabilities_j)\n mutual_loss += kl_loss / (model_num - 1)\n loss_summary['mutual_{}/{}'.format(trg_id, model_names[model_i])] = mutual_loss.item()\n\n should_turn_off_mutual_learning = self._should_turn_off_mutual_learning(self.epoch)\n coeff_mutual_learning = int(not should_turn_off_mutual_learning)\n\n total_loss += coeff_mutual_learning * mutual_loss\n # backward pass\n self.scaler.scale(total_loss).backward(retain_graph=False)\n for model_name in model_names:\n if self.clip_grad != 0 and step == 1:\n self.scaler.unscale_(self.optims[model_name])\n torch.nn.utils.clip_grad_norm_(self.models[model_name].parameters(), self.clip_grad)\n if not self.enable_sam and step == 1:\n self.scaler.step(self.optims[model_name])\n self.scaler.update()\n elif step == 1:\n assert self.enable_sam\n if self.clip_grad == 0:\n # if self.clip_grad == 0 this means that unscale_ wasn't applied\n # unscale parameters to perform SAM manipulations with parameters\n self.scaler.unscale_(self.optims[model_name]) \n overflow = self.optims[model_name].first_step(self.scaler)\n self.scaler.update() # update scaler after first step\n if overflow:\n print(\"Overflow occurred. Skipping step ...\")\n loss_summary['loss'] = total_loss.item()\n # skip second step if overflow occurred \n return loss_summary, avg_acc\n else:\n assert self.enable_sam and step==2\n if self.clip_grad == 0:\n self.scaler.unscale_(self.optims[model_name]) \n self.optims[model_name].second_step()\n self.scaler.update()\n\n loss_summary['loss'] = total_loss.item()\n\n return loss_summary, avg_acc\n\n def _single_model_losses(self, model, train_records, imgs, obj_ids, n_iter, model_name):\n model_output = model(imgs)\n all_logits = self._parse_model_output(model_output)\n\n total_loss = torch.zeros([], dtype=imgs.dtype, device=imgs.device)\n out_logits = []\n loss_summary = dict()\n\n num_trg_losses = 0\n avg_acc = 0\n\n for trg_id in range(self.num_targets):\n trg_mask = train_records['dataset_id'] == trg_id\n\n trg_obj_ids = obj_ids[trg_mask]\n trg_num_samples = trg_obj_ids.numel()\n if trg_num_samples == 0:\n out_logits.append(None)\n continue\n\n trg_logits = all_logits[trg_id][trg_mask]\n main_loss = self.main_losses[trg_id](trg_logits, trg_obj_ids)\n avg_acc += metrics.accuracy_multilabel(trg_logits, trg_obj_ids).item()\n loss_summary['main_{}/{}'.format(trg_id, model_name)] = main_loss.item()\n\n scaled_trg_logits = self.main_losses[trg_id].get_last_scale() * trg_logits\n out_logits.append(scaled_trg_logits)\n\n total_loss += main_loss\n num_trg_losses += 1\n\n total_loss /= float(num_trg_losses)\n avg_acc /= float(num_trg_losses)\n\n return total_loss, loss_summary, avg_acc, out_logits\n\n def kl_div_binary(self, x, y):\n ''' compute KL divergence between two tensors represented\n independent binary distributions'''\n # get binary distributions for two models with shape = (BxCx2)\n p = torch.stack((x, (1-x))).permute(1,2,0)\n q = torch.stack((y, (1-y))).permute(1,2,0)\n # log probabilities\n p_log = torch.log(p.add_(1e-8))\n # compute true KLDiv for each sample, than do the batchmean reduction\n return F.kl_div(p_log, q, reduction='none').sum(2).div_(x.size(1)).sum().div_(x.size(0))\n\n def _parse_model_output(self, model_output):\n all_logits = model_output[0] if isinstance(model_output, (tuple, list)) else model_output\n all_logits = all_logits if isinstance(all_logits, (tuple, list)) else [all_logits]\n\n return all_logits\n\n def exit_on_plateau_and_choose_best(self, top1, smooth_top1):\n '''\n The function returns a pair (should_exit, is_candidate_for_best).\n\n The function sets this checkpoint as a candidate for best if either it is the first checkpoint\n for this LR or this checkpoint is better then the previous best.\n\n The function sets should_exit = True if the overfitting is observed or the metric\n doesn't improves for a predetermined number of epochs.\n '''\n\n should_exit = False\n is_candidate_for_best = False\n current_metric = round(top1, 4)\n if smooth_top1 <= self.prev_smooth_top1:\n self.iter_to_wait += 1\n if self.iter_to_wait >= self.train_patience:\n print(\"The training should be stopped due to no improvements for {} epochs\".format(self.train_patience))\n should_exit = True\n else:\n self.iter_to_wait = 0\n\n if current_metric >= self.best_metric:\n self.best_metric = current_metric\n is_candidate_for_best = True\n\n self.prev_smooth_top1 = smooth_top1\n return should_exit, is_candidate_for_best\n"
] | [
[
"torch.nn.Linear",
"torch.nn.Identity",
"torch.cuda.amp.autocast",
"torch.nn.Sequential",
"torch.nn.BatchNorm2d",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.nn.PReLU",
"torch.nn.BatchNorm1d",
"torch.nn.InstanceNorm2d",
"torch.nn.AdaptiveAvgPool2d"
],
[
"torch.zeros",
"torch.sigmoid",
"torch.cuda.amp.autocast",
"torch.stack",
"torch.nn.ModuleList",
"torch.nn.functional.kl_div",
"torch.cuda.amp.GradScaler"
]
] |
Harshs27/lingvo | [
"bd396e651488b2e2c4a7416be077b4a0226c87c8",
"bd396e651488b2e2c4a7416be077b4a0226c87c8"
] | [
"lingvo/core/conv_layers_builder_test.py",
"lingvo/tools/audio_lib.py"
] | [
"# Lint as: python3\n# Copyright 2020 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 conv layers builder.\"\"\"\n\nfrom absl.testing import parameterized\nfrom lingvo import compat as tf\nfrom lingvo.core import bn_layers\nfrom lingvo.core import conv_layers_builder\nfrom lingvo.core import conv_layers_with_time_padding\nfrom lingvo.core import layers\nfrom lingvo.core import test_utils\nimport numpy as np\n\n\nclass ConvPaddedLayersTest(test_utils.TestCase):\n\n def _ConvTestHelper(self, dilation, stride, activation, batch_norm,\n weight_norm, in_dim, out_dim, filter_shape, conv_last,\n causal_conv):\n with self.session(use_gpu=True) as sess:\n p1 = layers.Conv2DLayer.Params().Set(\n name='conv_2d01',\n filter_shape=filter_shape + [in_dim, out_dim],\n filter_stride=stride,\n dilation_rate=dilation,\n activation=activation,\n batch_norm=batch_norm,\n weight_norm=weight_norm,\n bias=not batch_norm,\n conv_last=conv_last,\n causal_convolution=causal_conv)\n builder_params = conv_layers_builder.Builder.Params().Set(\n weight_norm=weight_norm)\n if batch_norm:\n norm_p = conv_layers_with_time_padding.ConvBatchNormLayer.Params().Set(\n decay=0.999)\n builder_params.norm_layer_tpl = norm_p\n else:\n builder_params.norm_layer_tpl = None\n p2 = builder_params.Instantiate().Conv2D(\n 'conv_2d02',\n in_dim,\n out_dim,\n filter_shape,\n stride=stride,\n dilation=dilation,\n activation=activation,\n conv_last=conv_last,\n is_causal=causal_conv)\n\n l1 = p1.Instantiate()\n l2 = p2.Instantiate()\n\n conv_in = tf.constant(np.random.normal(size=[4, 5, 6, 3]), tf.float32)\n conv_pad = np.full([4, 5], 0.0)\n conv_pad[2, 3] = 1.0\n conv_pad[2, 4] = 1.0\n conv_pad = tf.constant(conv_pad, tf.float32)\n l1_theta = l1.theta.Transform(tf.identity)\n l2_theta = l2.theta.Transform(tf.identity)\n conv_out1, out1_padding = l1.FProp(l1_theta, conv_in, conv_pad)\n conv_out2, out2_padding = l2.FProp(l2_theta, conv_in, conv_pad)\n\n tf.logging.info(l1_theta)\n tf.logging.info(l2_theta)\n l1_num_vars = l1_theta.Flatten()\n l2_num_var2 = l2_theta.Flatten()\n if len(l1_num_vars) != len(l2_num_var2):\n tf.logging.info(\n 'Mismatched number of vars: l1: %d vars, l2: %d vars',\n len(l1_num_vars), len(l2_num_var2))\n\n w1 = l1_theta.w\n w2 = l2_theta.conv_2d.w\n # b1 = l1_theta.b\n # b2 = l2_theta.bn_or_bias.b\n\n tf.global_variables_initializer().run()\n v1, p1 = sess.run([conv_out1, out1_padding])\n w1_v = sess.run(w1)\n v2, p2 = sess.run([conv_out2, out2_padding], feed_dict={w2: w1_v})\n\n self.assertAllClose(v1, v2)\n self.assertAllClose(p1, p2)\n\n def testConvBasic(self):\n dilation = [1, 1]\n stride = [2, 3]\n activation = 'NONE'\n batch_norm = False\n weight_norm = False\n in_dim = 3\n out_dim = 3\n filter_shape = [2, 2]\n conv_last = False\n causal_conv = False\n self._ConvTestHelper(dilation, stride, activation, batch_norm, weight_norm,\n in_dim, out_dim, filter_shape, conv_last, causal_conv)\n\n def testConvBnWnTanh(self):\n dilation = [1, 1]\n stride = [2, 3]\n activation = 'TANH'\n batch_norm = True\n weight_norm = True\n in_dim = 3\n out_dim = 3\n filter_shape = [2, 2]\n conv_last = False\n causal_conv = False\n self._ConvTestHelper(dilation, stride, activation, batch_norm, weight_norm,\n in_dim, out_dim, filter_shape, conv_last, causal_conv)\n\n def testConvGn(self):\n dilation = [1, 1]\n stride = [2, 3]\n activation = 'TANH'\n in_dim = 3\n out_dim = 4\n filter_shape = [2, 2]\n conv_last = False\n causal_conv = False\n\n with self.session(use_gpu=True) as sess:\n builder_params = conv_layers_builder.Builder.Params().Set(\n weight_norm=True)\n builder_params.norm_layer_tpl = bn_layers.GroupNormLayer.Params().Set(\n num_groups=2)\n p = builder_params.Instantiate().Conv2D(\n 'conv_2d02',\n in_dim,\n out_dim,\n filter_shape,\n stride=stride,\n dilation=dilation,\n activation=activation,\n conv_last=conv_last,\n is_causal=causal_conv)\n\n l = p.Instantiate()\n\n conv_in = tf.constant(np.random.normal(size=[4, 5, 6, 3]), tf.float32)\n conv_pad = np.full([4, 5], 0.0)\n conv_pad[2, 3] = 1.0\n conv_pad[2, 4] = 1.0\n conv_pad = tf.constant(conv_pad, tf.float32)\n conv_out, _ = l.FProp(l.theta, conv_in, conv_pad)\n tf.global_variables_initializer().run()\n v = sess.run(tf.reduce_sum(conv_out, 0))\n\n expected_out = [[[-0.35070014, -1.7821487, 0.8349923, 1.1709788],\n [-0.18872532, 0.9702145, 0.5534694, -1.1386856]],\n [[0.34970748, -0.5403709, -0.9809327, -2.0930214],\n [0.54232424, 1.1565661, 1.0349312, 1.3458138]],\n [[0, 0, 0, 0], [0, 0, 0, 0]]]\n\n self.assertAllClose(v, expected_out)\n\n def testConvLastWnTanh(self):\n dilation = [1, 1]\n stride = [2, 3]\n activation = 'TANH'\n batch_norm = False\n weight_norm = True\n in_dim = 3\n out_dim = 3\n filter_shape = [2, 2]\n conv_last = True\n causal_conv = False\n self._ConvTestHelper(dilation, stride, activation, batch_norm, weight_norm,\n in_dim, out_dim, filter_shape, conv_last, causal_conv)\n\n def testConvLastCausal(self):\n dilation = [1, 1]\n stride = [2, 3]\n activation = 'TANH'\n batch_norm = True\n weight_norm = True\n in_dim = 3\n out_dim = 3\n filter_shape = [2, 1]\n conv_last = True\n causal_conv = True\n self._ConvTestHelper(dilation, stride, activation, batch_norm, weight_norm,\n in_dim, out_dim, filter_shape, conv_last, causal_conv)\n\n def _DepthwiseConvTestHelper(self, dilation, stride, activation, batch_norm,\n weight_norm, in_dim, depth_multiplier,\n filter_shape, conv_last, causal_conv):\n with self.session(use_gpu=True) as sess:\n p1 = layers.DepthwiseConv2DLayer.Params().Set(\n name='conv_2d01',\n filter_shape=filter_shape + [in_dim, depth_multiplier],\n filter_stride=stride,\n dilation_rate=dilation,\n activation=activation,\n batch_norm=batch_norm,\n weight_norm=weight_norm,\n bias=not batch_norm,\n conv_last=conv_last,\n causal_convolution=causal_conv)\n builder_params = conv_layers_builder.Builder.Params().Set(\n weight_norm=weight_norm)\n if batch_norm:\n norm_p = conv_layers_with_time_padding.ConvBatchNormLayer.Params().Set(\n decay=0.999)\n builder_params.norm_layer_tpl = norm_p\n else:\n builder_params.norm_layer_tpl = None\n\n p2 = builder_params.Instantiate().DepthwiseConv2D(\n 'conv_2d02',\n in_dim,\n depth_multiplier,\n filter_shape,\n stride=stride,\n activation=activation,\n dilation=dilation,\n conv_last=conv_last,\n is_causal=causal_conv)\n\n l1 = p1.Instantiate()\n l2 = p2.Instantiate()\n\n conv_in = tf.constant(np.random.normal(size=[4, 5, 6, 3]), tf.float32)\n conv_pad = np.full([4, 5], 0.0)\n conv_pad[2, 3] = 1.0\n conv_pad[2, 4] = 1.0\n conv_pad = tf.constant(conv_pad, tf.float32)\n l1_theta = l1.theta.Transform(tf.identity)\n l2_theta = l2.theta.Transform(tf.identity)\n conv_out1, out1_padding = l1.FProp(l1_theta, conv_in, conv_pad)\n conv_out2, out2_padding = l2.FProp(l2_theta, conv_in, conv_pad)\n\n tf.logging.info(l1_theta)\n tf.logging.info(l2_theta)\n l1_num_vars = l1_theta.Flatten()\n l2_num_var2 = l2_theta.Flatten()\n if len(l1_num_vars) != len(l2_num_var2):\n tf.logging.info(\n 'Mismatched number of vars: l1: %d vars, l2: %d vars',\n len(l1_num_vars), len(l2_num_var2))\n\n w1 = l1_theta.w\n w2 = l2_theta.conv_2d.w\n # b1 = l1_theta.b\n # b2 = l2_theta.bn_or_bias.b\n\n tf.global_variables_initializer().run()\n v1, p1 = sess.run([conv_out1, out1_padding])\n w1_v = sess.run([w1])[0]\n v2, p2 = sess.run([conv_out2, out2_padding], feed_dict={w2: w1_v})\n\n self.assertAllClose(v1, v2)\n self.assertAllClose(p1, p2)\n\n def testDepthConvBasic(self):\n dilation = [1, 1]\n stride = [2, 2]\n activation = 'NONE'\n batch_norm = False\n weight_norm = False\n in_dim = 3\n depth_multiplier = 2\n filter_shape = [2, 2]\n conv_last = False\n causal_conv = False\n self._DepthwiseConvTestHelper(dilation, stride, activation, batch_norm,\n weight_norm, in_dim, depth_multiplier,\n filter_shape, conv_last, causal_conv)\n\n def testDepthConvBnWnTanh(self):\n dilation = [1, 1]\n stride = [2, 2]\n activation = 'TANH'\n batch_norm = True\n weight_norm = True\n in_dim = 3\n depth_multiplier = 3\n filter_shape = [2, 2]\n conv_last = False\n causal_conv = False\n self._DepthwiseConvTestHelper(dilation, stride, activation, batch_norm,\n weight_norm, in_dim, depth_multiplier,\n filter_shape, conv_last, causal_conv)\n\n def testDepthConvGn(self):\n dilation = [1, 1]\n stride = [2, 2]\n activation = 'TANH'\n in_dim = 4\n depth_multiplier = 1\n filter_shape = [2, 2]\n conv_last = False\n causal_conv = False\n\n with self.session(use_gpu=True) as sess:\n builder_params = conv_layers_builder.Builder.Params().Set(\n weight_norm=True)\n builder_params.norm_layer_tpl = bn_layers.GroupNormLayer.Params().Set(\n num_groups=2)\n p = builder_params.Instantiate().DepthwiseConv2D(\n 'conv_2d02',\n in_dim,\n depth_multiplier,\n filter_shape,\n stride=stride,\n activation=activation,\n dilation=dilation,\n conv_last=conv_last,\n is_causal=causal_conv)\n l = p.Instantiate()\n\n conv_in = tf.constant(np.random.normal(size=[4, 5, 6, 4]), tf.float32)\n conv_pad = np.full([4, 5], 0.0)\n conv_pad[2, 3] = 1.0\n conv_pad[2, 4] = 1.0\n conv_pad = tf.constant(conv_pad, tf.float32)\n conv_out, _ = l.FProp(l.theta, conv_in, conv_pad)\n tf.global_variables_initializer().run()\n v = sess.run(tf.reduce_sum(conv_out, 0))\n\n expected_out = [[[-0.77095497, 0.30285388, -0.05714864, 1.0386012],\n [0.74034333, 0.04982221, -0.41769135, -2.9531932],\n [-0.2647084, -0.1936804, 0.6598473, 0.42537105]],\n [[1.3095646, -0.85996866, 2.2734299, -1.8457952],\n [-0.9542263, -0.14199251, 0.51472515, 0.91931283],\n [0.47267163, 1.4824618, 0.4548889, 0.93488806]],\n [[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]]]\n\n self.assertAllClose(expected_out, v)\n\n def testDepthConvLastWnTanh(self):\n dilation = [1, 1]\n stride = [2, 2]\n activation = 'TANH'\n batch_norm = False\n weight_norm = True\n in_dim = 3\n depth_multiplier = 3\n filter_shape = [2, 2]\n conv_last = True\n causal_conv = False\n self._DepthwiseConvTestHelper(dilation, stride, activation, batch_norm,\n weight_norm, in_dim, depth_multiplier,\n filter_shape, conv_last, causal_conv)\n\n def testDepthConvLastCausal(self):\n dilation = [1, 1]\n stride = [2, 2]\n activation = 'TANH'\n batch_norm = True\n weight_norm = True\n in_dim = 3\n depth_multiplier = 3\n filter_shape = [2, 1]\n conv_last = True\n causal_conv = True\n self._DepthwiseConvTestHelper(dilation, stride, activation, batch_norm,\n weight_norm, in_dim, depth_multiplier,\n filter_shape, conv_last, causal_conv)\n\n def _SeparableConvTestHelper(self, dilation, stride, activation, batch_norm,\n weight_norm, in_dim, depth_multiplier, out_dim,\n filter_shape, conv_last, causal_conv,\n assert_equality=True):\n with self.session(use_gpu=True) as sess:\n p1 = layers.SeparableConv2DLayer.Params().Set(\n name='conv_2d01',\n filter_shape=filter_shape + [in_dim, out_dim],\n depth_multiplier=depth_multiplier,\n filter_stride=stride,\n dilation_rate=dilation,\n activation=activation,\n batch_norm=batch_norm,\n weight_norm=weight_norm,\n bias=not batch_norm,\n conv_last=conv_last,\n causal_convolution=causal_conv)\n builder_params = conv_layers_builder.Builder.Params().Set(\n weight_norm=weight_norm)\n if batch_norm:\n norm_p = conv_layers_with_time_padding.ConvBatchNormLayer.Params().Set(\n decay=0.999)\n builder_params.norm_layer_tpl = norm_p\n else:\n builder_params.norm_layer_tpl = None\n p2 = builder_params.Instantiate().SeparableConv2D(\n 'conv_2d02',\n in_dim,\n out_dim,\n depth_multiplier,\n filter_shape,\n stride=stride,\n activation=activation,\n dilation=dilation,\n conv_last=conv_last,\n is_causal=causal_conv)\n\n l1 = p1.Instantiate()\n l2 = p2.Instantiate()\n\n conv_in = tf.constant(np.random.normal(size=[4, 5, 6, 3]), tf.float32)\n conv_pad = np.full([4, 5], 0.0)\n conv_pad[2, 3] = 1.0\n conv_pad[2, 4] = 1.0\n conv_pad = tf.constant(conv_pad, tf.float32)\n l1_theta = l1.theta.Transform(tf.identity)\n l2_theta = l2.theta.Transform(tf.identity)\n conv_out1, out1_padding = l1.FProp(l1_theta, conv_in, conv_pad)\n conv_out2, out2_padding = l2.FProp(l2_theta, conv_in, conv_pad)\n\n tf.logging.info(l1_theta)\n tf.logging.info(l2_theta)\n l1_num_vars = l1_theta.Flatten()\n l2_num_var2 = l2_theta.Flatten()\n if len(l1_num_vars) != len(l2_num_var2):\n tf.logging.info(\n 'Mismatched number of vars: l1: %d vars, l2: %d vars',\n len(l1_num_vars), len(l2_num_var2))\n\n pointwise_conv_w1 = l1_theta.w\n depth_conv_w1 = l1_theta.depthwise_conv.w\n pointwise_conv_w2 = l2_theta.conv_1x1.w\n depth_conv_w2 = l2_theta.conv_2d.w\n # b1 = l1_theta.b\n # b2 = l2_theta.bn_or_bias.b\n tf.global_variables_initializer().run()\n v1, p1 = sess.run([conv_out1, out1_padding])\n p_w1_v, d_w1_v = sess.run([pointwise_conv_w1, depth_conv_w1])\n v2, p2 = sess.run([conv_out2, out2_padding],\n feed_dict={\n pointwise_conv_w2: p_w1_v,\n depth_conv_w2: d_w1_v\n })\n\n if assert_equality:\n self.assertAllClose(v1, v2)\n self.assertAllClose(p1, p2)\n\n def testSeparableConv2DLayerBasic(self):\n dilation = [1, 1]\n stride = [2, 2]\n activation = 'NONE'\n batch_norm = False\n weight_norm = False\n in_dim = 3\n depth_multiplier = 3\n out_dim = 2\n filter_shape = [2, 2]\n conv_last = False\n causal_conv = False\n self._SeparableConvTestHelper(dilation, stride, activation, batch_norm,\n weight_norm, in_dim, depth_multiplier,\n out_dim, filter_shape, conv_last, causal_conv)\n\n def testSeparableConvWnWnTanh(self):\n dilation = [1, 1]\n stride = [2, 2]\n activation = 'TANH'\n batch_norm = False\n weight_norm = True\n in_dim = 3\n depth_multiplier = 3\n out_dim = 2\n filter_shape = [2, 1]\n conv_last = False\n causal_conv = True\n self._SeparableConvTestHelper(dilation, stride, activation, batch_norm,\n weight_norm, in_dim, depth_multiplier,\n out_dim, filter_shape, conv_last, causal_conv)\n\n def testSeparableConvLastBnWnTanh(self):\n dilation = [1, 1]\n stride = [2, 2]\n activation = 'TANH'\n batch_norm = True\n weight_norm = True\n in_dim = 3\n depth_multiplier = 3\n out_dim = 2\n filter_shape = [2, 1]\n conv_last = True\n causal_conv = True\n # New implementation is not equivallent to the old.\n self._SeparableConvTestHelper(dilation, stride, activation, batch_norm,\n weight_norm, in_dim, depth_multiplier,\n out_dim, filter_shape, conv_last, causal_conv,\n assert_equality=False)\n\n def testSeparableConvGn(self):\n dilation = [1, 1]\n stride = [2, 2]\n activation = 'TANH'\n in_dim = 4\n depth_multiplier = 1\n out_dim = 2\n filter_shape = [2, 1]\n conv_last = True\n causal_conv = True\n\n with self.session(use_gpu=True) as sess:\n builder_params = conv_layers_builder.Builder.Params().Set(\n weight_norm=True)\n builder_params.norm_layer_tpl = bn_layers.GroupNormLayer.Params().Set(\n num_groups=2)\n p = builder_params.Instantiate().SeparableConv2D(\n 'conv_2d02',\n in_dim,\n out_dim,\n depth_multiplier,\n filter_shape,\n stride=stride,\n activation=activation,\n dilation=dilation,\n conv_last=conv_last,\n is_causal=causal_conv)\n\n l = p.Instantiate()\n\n conv_in = tf.constant(np.random.normal(size=[4, 5, 6, 4]), tf.float32)\n conv_pad = np.full([4, 5], 0.0)\n conv_pad[2, 3] = 1.0\n conv_pad[2, 4] = 1.0\n conv_pad = tf.constant(conv_pad, tf.float32)\n conv_out, _ = l.FProp(l.theta, conv_in, conv_pad)\n tf.global_variables_initializer().run()\n v = sess.run(tf.reduce_sum(conv_out, 0))\n\n expected_out = [[[0.00963847, -0.04019006], [0.36265337, -0.06592329],\n [0.65582913, -0.1533944]],\n [[0.7512939, -0.7282307], [0.96100605, -1.9509676],\n [0.4639647, 0.2485837]], [[0., 0.], [0., 0.], [0., 0.]]]\n\n self.assertAllClose(expected_out, v)\n\n\nclass CausalPoolingLayerTest(test_utils.TestCase, parameterized.TestCase):\n \"\"\"Tests for CausalPoolingLayer.\"\"\"\n\n @parameterized.named_parameters(\n {\n 'testcase_name': 'max_pooling',\n 'pooling_type': 'MAX',\n 'left_context': 2,\n 'inputs': np.array([-2, 0, 2, 4, 0, 0]),\n 'input_paddings': np.array([0, 0, 0, 0, 1, 1]),\n 'expected_output': np.array([-2, 0, 2, 4, 0, 0]),\n 'expected_output_padding': np.array([0, 0, 0, 0, 1, 1]),\n }, {\n 'testcase_name': 'avg_pooling',\n 'pooling_type': 'AVG',\n 'left_context': 2,\n 'inputs': np.array([-2, 0, 2, 4, 0, 0]),\n 'input_paddings': np.array([0, 0, 0, 0, 1, 1]),\n 'expected_output': np.array([-2, -1, 1, 3, 0, 0]),\n 'expected_output_padding': np.array([0, 0, 0, 0, 1, 1]),\n }, {\n 'testcase_name': 'max_pooling_large_window',\n 'pooling_type': 'MAX',\n 'left_context': 10,\n 'inputs': np.array([-2, 0, 2, 4, 0, 0]),\n 'input_paddings': np.array([0, 0, 0, 0, 1, 1]),\n 'expected_output': np.array([-2, 0, 2, 4, 0, 0]),\n 'expected_output_padding': np.array([0, 0, 0, 0, 1, 1]),\n }, {\n 'testcase_name': 'avg_pooling_large_window',\n 'pooling_type': 'AVG',\n 'left_context': 10,\n 'inputs': np.array([-2, 0, 2, 4, 0, 0]),\n 'input_paddings': np.array([0, 0, 0, 0, 1, 1]),\n 'expected_output': np.array([-2, -1, 0, 1, 0, 0]),\n 'expected_output_padding': np.array([0, 0, 0, 0, 1, 1]),\n }, {\n 'testcase_name': 'avg_pooling_infinte_window',\n 'pooling_type': 'AVG',\n 'left_context': -1,\n 'inputs': np.array([-2, 0, 2, 4, 0, 0]),\n 'input_paddings': np.array([0, 0, 0, 0, 1, 1]),\n 'expected_output': np.array([-2, -1, 0, 1, 0, 0]),\n 'expected_output_padding': np.array([0, 0, 0, 0, 1, 1]),\n })\n def testSimpleCase(self, pooling_type, left_context, inputs, input_paddings,\n expected_output, expected_output_padding):\n inputs = inputs[np.newaxis, :, np.newaxis, np.newaxis]\n input_paddings = input_paddings[np.newaxis, :]\n param = conv_layers_builder.CausalPoolingLayer.Params().Set(\n name='test_layer', pooling_type=pooling_type, left_context=left_context)\n pooling_layer = param.Instantiate()\n with self.session(use_gpu=True) as sess:\n inputs = tf.convert_to_tensor(inputs, dtype=tf.float32)\n input_paddings = tf.convert_to_tensor(input_paddings, dtype=tf.float32)\n output, output_paddings = pooling_layer.FPropDefaultTheta(\n inputs, input_paddings)\n tf.global_variables_initializer().run()\n output_val, output_paddings_val = sess.run([output, output_paddings])\n\n self.assertAllClose(expected_output, output_val.flatten())\n self.assertAllEqual(expected_output_padding, output_paddings_val.flatten())\n\n\nif __name__ == '__main__':\n tf.test.main()\n",
"# Lint as: python3\n# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Audio library.\"\"\"\n\nimport subprocess\nimport lingvo.compat as tf\nfrom lingvo.core import py_utils\nfrom lingvo.tasks.asr import frontend as asr_frontend\n\nfrom tensorflow.python.ops import gen_audio_ops as audio_ops # pylint: disable=g-direct-tensorflow-import\n\n\n# There are two ways to decode a wav in tensorflow:\n# Through the tensorflow native audio decoder, exported\n# via framework, or via tf.contrib.ffmpeg.decode_audio.\n# While the latter could technically support FLAC, it does\n# not. It also adds an extra dependency on ffmpeg.\n\n\ndef DecodeFlacToWav(input_bytes):\n \"\"\"Decode a FLAC byte string to WAV.\"\"\"\n p = subprocess.Popen(\n ['sox', '-t', 'flac', '-', '-t', 'wav', '-'],\n stdin=subprocess.PIPE,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n out, err = p.communicate(input=input_bytes)\n assert p.returncode == 0, err\n return out\n\n\ndef DecodeWav(input_bytes):\n \"\"\"Decode a wav file from its contents.\n\n Args:\n input_bytes: a byte array or Tensor with the wav file contents.\n\n Returns:\n A pair of Tensor for sample rate, decoded samples.\n \"\"\"\n result = tf.audio.decode_wav(input_bytes)\n return result.sample_rate, result.audio\n\n\ndef AudioToMfcc(sample_rate, audio, window_size_ms, window_stride_ms,\n num_coefficients):\n window_size_samples = sample_rate * window_size_ms // 1000\n window_stride_samples = sample_rate * window_stride_ms // 1000\n spectrogram = audio_ops.audio_spectrogram(\n audio,\n window_size=window_size_samples,\n stride=window_stride_samples,\n magnitude_squared=True)\n mfcc = audio_ops.mfcc(\n spectrogram, sample_rate, dct_coefficient_count=num_coefficients)\n return mfcc\n\n\ndef ExtractLogMelFeatures(wav_bytes_t):\n \"\"\"Create Log-Mel Filterbank Features from raw bytes.\n\n Args:\n wav_bytes_t: Tensor representing raw wav file as a string of bytes. It is\n currently assumed that the wav file is encoded at 16KHz (see DecodeWav,\n below).\n\n Returns:\n A Tensor representing three stacked log-Mel filterbank energies, sub-sampled\n every three frames.\n \"\"\"\n\n def _CreateAsrFrontend():\n \"\"\"Parameters corresponding to default ASR frontend.\"\"\"\n p = asr_frontend.MelAsrFrontend.Params()\n p.sample_rate = 16000.\n p.frame_size_ms = 25.\n p.frame_step_ms = 10.\n p.num_bins = 80\n p.lower_edge_hertz = 125.\n p.upper_edge_hertz = 7600.\n p.preemph = 0.97\n p.noise_scale = 0.\n p.pad_end = False\n return p.Instantiate()\n\n sample_rate, audio = DecodeWav(wav_bytes_t)\n audio *= 32768\n # Remove channel dimension, since we have a single channel.\n audio = tf.squeeze(audio, axis=1)\n # TODO(drpng): make batches.\n audio = tf.expand_dims(audio, axis=0)\n static_sample_rate = 16000\n mel_frontend = _CreateAsrFrontend()\n with tf.control_dependencies(\n [tf.assert_equal(sample_rate, static_sample_rate)]):\n outputs = mel_frontend.FPropDefaultTheta(\n py_utils.NestedMap(src_inputs=audio, paddings=tf.zeros_like(audio)))\n log_mel = outputs.src_inputs\n return log_mel\n"
] | [
[
"numpy.full",
"numpy.array",
"numpy.random.normal"
],
[
"tensorflow.python.ops.gen_audio_ops.mfcc",
"tensorflow.python.ops.gen_audio_ops.audio_spectrogram"
]
] |
541867329/pydata-notebook | [
"867f204d7abac96dbae80e6cdd2e3661e554d1dd"
] | [
"mydemo/matplotlibDemo/clickEvent.py"
] | [
"from matplotlib.pyplot import figure, show\nimport numpy as npy\nfrom numpy.random import rand\n\nif 1: # picking on a scatter plot (matplotlib.collections.RegularPolyCollection)\n\n x, y, c, s = rand(4, 100)\n\n\n def onpick3(event):\n ind = event.ind\n print('onpick3 scatter:', ind, npy.take(x, ind), npy.take(y, ind))\n\n\n fig = figure()\n ax1 = fig.add_subplot(111)\n col = ax1.scatter(x, y, 100 * s, c, picker=True)\n # fig.savefig('pscoll.eps')\n fig.canvas.mpl_connect('pick_event', onpick3)\n\nshow()\n"
] | [
[
"matplotlib.pyplot.show",
"numpy.random.rand",
"numpy.take",
"matplotlib.pyplot.figure"
]
] |
suresh-guttikonda/iGibson | [
"a69e623058180146466cd52d4bb3c00d1facdacf",
"a69e623058180146466cd52d4bb3c00d1facdacf"
] | [
"igibson/robots/jr2_robot.py",
"igibson/utils/data_utils/ext_object/scripts_wip/get_obj_stable_rotations.py"
] | [
"import gym\nimport numpy as np\n\nfrom igibson.robots.robot_locomotor import LocomotorRobot\n\n\nclass JR2(LocomotorRobot):\n \"\"\"\n JR2 robot (no arm)\n Reference: https://cvgl.stanford.edu/projects/jackrabbot/\n Uses joint velocity control\n \"\"\"\n\n def __init__(self, config):\n self.config = config\n self.velocity = config.get(\"velocity\", 1.0)\n LocomotorRobot.__init__(\n self,\n \"jr2_urdf/jr2.urdf\",\n action_dim=4,\n scale=config.get(\"robot_scale\", 1.0),\n is_discrete=config.get(\"is_discrete\", True),\n control=\"velocity\",\n )\n\n def set_up_continuous_action_space(self):\n \"\"\"\n Set up continuous action space\n \"\"\"\n self.action_space = gym.spaces.Box(shape=(self.action_dim,), low=-1.0, high=1.0, dtype=np.float32)\n self.action_high = self.velocity * np.ones([self.action_dim])\n self.action_low = -self.action_high\n\n def set_up_discrete_action_space(self):\n \"\"\"\n Set up discrete action space\n \"\"\"\n self.action_list = [\n [self.velocity, self.velocity, 0, self.velocity],\n [-self.velocity, -self.velocity, 0, -self.velocity],\n [self.velocity, -self.velocity, -self.velocity, 0],\n [-self.velocity, self.velocity, self.velocity, 0],\n [0, 0, 0, 0],\n ]\n self.action_space = gym.spaces.Discrete(len(self.action_list))\n self.setup_keys_to_action()\n\n def setup_keys_to_action(self):\n self.keys_to_action = {\n (ord(\"w\"),): 0, # forward\n (ord(\"s\"),): 1, # backward\n (ord(\"d\"),): 2, # turn right\n (ord(\"a\"),): 3, # turn left\n (): 4,\n }\n",
"\"\"\"\nCredit: Andrey Kurenkov\n\"\"\"\n\nimport argparse\nimport json\nimport math\nimport os\nimport signal\nimport xml.etree.ElementTree as ET\n\nimport numpy as np\nimport pybullet as p\nimport trimesh\nfrom pyquaternion import Quaternion\n\n\"\"\"\nAnalyzes a model for possible ways to place it flat on a surface.\nUse by running without --ask_probs or --save_json to see rotations, and then with to save them with probabilities.\n\"\"\"\n\n\ndef viz_transform(body_id, mesh, transform):\n quat = Quaternion(matrix=transform)\n r = quat.real\n v = quat.vector\n p.resetBasePositionAndOrientation(\n body_id, [0, 0, mesh.extents[2] / 2.0], [quat.vector[0], quat.vector[1], quat.vector[2], quat.real]\n )\n return r, v\n\n\ndef compute_poses(mesh, threshold):\n poses = trimesh.poses.compute_stable_poses(mesh, n_samples=5, threshold=threshold)\n return poses\n\n\nclass TimeoutError(Exception):\n pass\n\n\ndef handler(signum, frame):\n raise TimeoutError()\n\n\ndef main(args):\n p.connect(p.GUI)\n cat_ids = []\n if args.object_cat is not None:\n cat_dir = \"data/ig_dataset/objects/%s\" % (args.object_cat)\n for obj_id in os.listdir(cat_dir):\n cat_ids.append((args.object_cat, obj_id))\n elif args.cat_file is not None:\n with open(args.cat_file, \"r\") as f:\n for line in f:\n cat = line.strip()\n cat_dir = \"data/ig_dataset/objects/%s\" % (cat)\n for obj_id in os.listdir(cat_dir):\n cat_ids.append((cat, obj_id))\n else:\n with open(args.cat_id_file, \"r\") as f:\n for line in f:\n cat_ids.append(line.strip().split(\"/\"))\n for object_cat, object_id in cat_ids:\n print(\"Processing %s %s\" % (object_cat, object_id))\n metadata_file = \"data/ig_dataset/objects/%s/%s/misc/metadata.json\" % (object_cat, object_id)\n with open(metadata_file, \"r\") as f:\n metadata = json.load(f)\n\n if args.skip_processed and \"orientations\" in metadata and len(metadata[\"orientations\"]) > 0:\n continue\n\n urdf_file = \"data/ig_dataset/objects/%s/%s/%s.urdf\" % (object_cat, object_id, object_id)\n tree = ET.parse(urdf_file)\n joints = tree.findall(\"joint\")\n links = tree.findall(\"link\")\n # Find the base link\n children_links = [joint.find(\"child\").attrib[\"link\"] for joint in joints]\n base_link = [link for link in links if link.attrib[\"name\"] not in children_links][0]\n object_file = base_link.find(\"collision/geometry/mesh\").attrib[\"filename\"]\n # Use the collision mesh of the base link\n object_file = \"data/ig_dataset/objects/%s/%s/%s\" % (object_cat, object_id, object_file)\n\n mesh = trimesh.load(object_file, force=\"mesh\")\n\n poses = [np.eye(4)]\n # set the timeout handler\n signal.signal(signal.SIGALRM, handler)\n signal.alarm(10)\n try:\n new_poses = compute_poses(mesh, args.threshold)\n for pose in new_poses[0]:\n poses.append(pose)\n except TimeoutError as exc:\n pass\n finally:\n signal.alarm(0)\n visualShapeId = p.createVisualShape(shapeType=p.GEOM_MESH, fileName=object_file)\n collisionShapeId = p.createCollisionShape(shapeType=p.GEOM_MESH, fileName=object_file)\n body_id = p.createMultiBody(baseCollisionShapeIndex=collisionShapeId, baseVisualShapeIndex=visualShapeId)\n\n info_dict = {}\n aabb = p.getAABB(body_id)\n print(\"Showing all stable placement rotations:\")\n dicts = []\n\n for i in range(len(poses)):\n print(\"Num poses:\", len(poses))\n rotation_dict = {}\n transform = poses[i]\n r, v = viz_transform(body_id, mesh, transform)\n prob = 0\n if args.save_json:\n inp = input(\"Enter probability of rotation, or +x/-x or/ +y/-y or +z/-z to rotate:\")\n if inp == \"\":\n continue\n while inp[0] == \"+\" or inp[0] == \"-\":\n rot_num = float(inp.split()[1])\n if inp[0] == \"-\":\n rot_num *= -1\n if inp[1] == \"z\":\n rot = np.array(\n [\n [math.cos(math.pi * rot_num), -math.sin(math.pi * rot_num), 0.0, 0.0],\n [math.sin(math.pi * rot_num), math.cos(math.pi * rot_num), 0.0, 0.0],\n [0.0, 0.0, 1.0, 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ]\n )\n elif inp[1] == \"y\":\n rot = np.array(\n [\n [math.cos(math.pi * rot_num), 0.0, math.sin(math.pi * rot_num), 0.0],\n [0.0, 1.0, 0.0, 0.0],\n [-math.sin(math.pi * rot_num), 0.0, math.cos(math.pi * rot_num), 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ]\n )\n elif inp[1] == \"x\":\n rot = np.array(\n [\n [1.0, 0.0, 0.0, 0.0],\n [0.0, math.cos(math.pi * rot_num), -math.sin(math.pi * rot_num), 0.0],\n [0.0, math.sin(math.pi * rot_num), math.cos(math.pi * rot_num), 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ]\n )\n transform = np.matmul(rot, transform)\n r, v = viz_transform(body_id, mesh, transform)\n inp = input(\"Enter probability of rotation, or +/- to rotate about Z:\")\n prob = float(inp)\n variation = float(input(\"Enter variation about Z (0-1):\"))\n rotation_dict[\"prob\"] = prob\n rotation_dict[\"variation\"] = variation\n else:\n skip = input(\"Rotation %d: (press enter to continue)\" % (i + 1))\n rotation_dict[\"rotation\"] = [float(v[0]), float(v[1]), float(v[2]), float(r)]\n aabb = p.getAABB(body_id)\n size = [aabb[1][0] - aabb[0][0], aabb[1][1] - aabb[0][1], aabb[1][2] - aabb[0][2]]\n print(\"Bounding box size=%s\" % str(size))\n rotation_dict[\"size\"] = size\n if prob > 0:\n dicts.append(rotation_dict)\n\n print(\"Summary:\")\n for d in dicts:\n print(d)\n\n if args.save_json:\n metadata[\"orientations\"] = dicts\n\n with open(metadata_file, \"w\") as f:\n documents = json.dump(metadata, f)\n\n p.removeBody(body_id)\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(\n description=\"Analyze objects that can be placed in a container for their plausible rotations.\"\n )\n parser.add_argument(\"--object_cat\", type=str, default=None, help=\"A category to set rotation for\")\n parser.add_argument(\n \"--cat_id_file\",\n type=str,\n default=None,\n help=\"A text file containing category and id of each object to set rotation for, one per line\",\n )\n parser.add_argument(\n \"--cat_file\",\n type=str,\n default=None,\n help=\"A text file containing category and id of each object to set rotation for, one per line\",\n )\n parser.add_argument(\n \"--save_json\", action=\"store_true\", help=\"Whether to ask for and save orientations and probabilities to json.\"\n )\n parser.add_argument(\"--threshold\", type=float, default=0.03, help=\"Threshold for including orientations or not.\")\n parser.add_argument(\"--skip_processed\", action=\"store_true\")\n args = parser.parse_args()\n if args.object_cat is None and args.cat_id_file is None and args.cat_file is None:\n raise ValueError(\"Either object_cat or cat_id_file or cat_file must be set\")\n main(args)\n"
] | [
[
"numpy.ones"
],
[
"numpy.matmul",
"numpy.eye"
]
] |
teja-ambati1202/Insurance-Fraud-Detection | [
"a9bbdd5a2af68e0e90f8e16ba43129bab709614b"
] | [
"Training_Raw_data_validation/rawValidation.py"
] | [
"import sqlite3\r\nfrom datetime import datetime\r\nfrom os import listdir\r\nimport os\r\nimport re\r\nimport json\r\nimport shutil\r\nimport pandas as pd\r\nfrom application_logging.logger import App_Logger\r\n\r\n\r\n\r\n\r\n\r\nclass Raw_Data_validation:\r\n\r\n \"\"\"\r\n This class shall be used for handling all the validation done on the Raw Training Data!!.\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n\r\n def __init__(self,path):\r\n self.Batch_Directory = path\r\n self.schema_path = 'schema_training.json'\r\n self.logger = App_Logger()\r\n\r\n\r\n def valuesFromSchema(self):\r\n \"\"\"\r\n Method Name: valuesFromSchema\r\n Description: This method extracts all the relevant information from the pre-defined \"Schema\" file.\r\n Output: LengthOfDateStampInFile, LengthOfTimeStampInFile, column_names, Number of Columns\r\n On Failure: Raise ValueError,KeyError,Exception\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n try:\r\n with open(self.schema_path, 'r') as f:\r\n dic = json.load(f)\r\n f.close()\r\n pattern = dic['SampleFileName']\r\n LengthOfDateStampInFile = dic['LengthOfDateStampInFile']\r\n LengthOfTimeStampInFile = dic['LengthOfTimeStampInFile']\r\n column_names = dic['ColName']\r\n NumberofColumns = dic['NumberofColumns']\r\n\r\n file = open(\"Training_Logs/valuesfromSchemaValidationLog.txt\", 'a+')\r\n message =\"LengthOfDateStampInFile:: %s\" %LengthOfDateStampInFile + \"\\t\" + \"LengthOfTimeStampInFile:: %s\" % LengthOfTimeStampInFile +\"\\t \" + \"NumberofColumns:: %s\" % NumberofColumns + \"\\n\"\r\n self.logger.log(file,message)\r\n\r\n file.close()\r\n\r\n\r\n\r\n except ValueError:\r\n file = open(\"Training_Logs/valuesfromSchemaValidationLog.txt\", 'a+')\r\n self.logger.log(file,\"ValueError:Value not found inside schema_training.json\")\r\n file.close()\r\n raise ValueError\r\n\r\n except KeyError:\r\n file = open(\"Training_Logs/valuesfromSchemaValidationLog.txt\", 'a+')\r\n self.logger.log(file, \"KeyError:Key value error incorrect key passed\")\r\n file.close()\r\n raise KeyError\r\n\r\n except Exception as e:\r\n file = open(\"Training_Logs/valuesfromSchemaValidationLog.txt\", 'a+')\r\n self.logger.log(file, str(e))\r\n file.close()\r\n raise e\r\n\r\n return LengthOfDateStampInFile, LengthOfTimeStampInFile, column_names, NumberofColumns\r\n\r\n\r\n def manualRegexCreation(self):\r\n \"\"\"\r\n Method Name: manualRegexCreation\r\n Description: This method contains a manually defined regex based on the \"FileName\" given in \"Schema\" file.\r\n This Regex is used to validate the filename of the training data.\r\n Output: Regex pattern\r\n On Failure: None\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n regex = \"['fraudDetection']+['\\_'']+[\\d_]+[\\d]+\\.csv\"\r\n return regex\r\n\r\n def createDirectoryForGoodBadRawData(self):\r\n\r\n \"\"\"\r\n Method Name: createDirectoryForGoodBadRawData\r\n Description: This method creates directories to store the Good Data and Bad Data\r\n after validating the training data.\r\n\r\n Output: None\r\n On Failure: OSError\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n\r\n try:\r\n path = os.path.join(\"Training_Raw_files_validated/\", \"Good_Raw/\")\r\n if not os.path.isdir(path):\r\n os.makedirs(path)\r\n path = os.path.join(\"Training_Raw_files_validated/\", \"Bad_Raw/\")\r\n if not os.path.isdir(path):\r\n os.makedirs(path)\r\n\r\n except OSError as ex:\r\n file = open(\"Training_Logs/GeneralLog.txt\", 'a+')\r\n self.logger.log(file,\"Error while creating Directory %s:\" % ex)\r\n file.close()\r\n raise OSError\r\n\r\n def deleteExistingGoodDataTrainingFolder(self):\r\n\r\n \"\"\"\r\n Method Name: deleteExistingGoodDataTrainingFolder\r\n Description: This method deletes the directory made to store the Good Data\r\n after loading the data in the table. Once the good files are\r\n loaded in the DB,deleting the directory ensures space optimization.\r\n Output: None\r\n On Failure: OSError\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n\r\n try:\r\n path = 'Training_Raw_files_validated/'\r\n # if os.path.isdir(\"ids/\" + userName):\r\n # if os.path.isdir(path + 'Bad_Raw/'):\r\n # shutil.rmtree(path + 'Bad_Raw/')\r\n if os.path.isdir(path + 'Good_Raw/'):\r\n shutil.rmtree(path + 'Good_Raw/')\r\n file = open(\"Training_Logs/GeneralLog.txt\", 'a+')\r\n self.logger.log(file,\"GoodRaw directory deleted successfully!!!\")\r\n file.close()\r\n except OSError as s:\r\n file = open(\"Training_Logs/GeneralLog.txt\", 'a+')\r\n self.logger.log(file,\"Error while Deleting Directory : %s\" %s)\r\n file.close()\r\n raise OSError\r\n\r\n def deleteExistingBadDataTrainingFolder(self):\r\n\r\n \"\"\"\r\n Method Name: deleteExistingBadDataTrainingFolder\r\n Description: This method deletes the directory made to store the bad Data.\r\n Output: None\r\n On Failure: OSError\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n\r\n try:\r\n path = 'Training_Raw_files_validated/'\r\n if os.path.isdir(path + 'Bad_Raw/'):\r\n shutil.rmtree(path + 'Bad_Raw/')\r\n file = open(\"Training_Logs/GeneralLog.txt\", 'a+')\r\n self.logger.log(file,\"BadRaw directory deleted before starting validation!!!\")\r\n file.close()\r\n except OSError as s:\r\n file = open(\"Training_Logs/GeneralLog.txt\", 'a+')\r\n self.logger.log(file,\"Error while Deleting Directory : %s\" %s)\r\n file.close()\r\n raise OSError\r\n\r\n def moveBadFilesToArchiveBad(self):\r\n\r\n \"\"\"\r\n Method Name: moveBadFilesToArchiveBad\r\n Description: This method deletes the directory made to store the Bad Data\r\n after moving the data in an archive folder. We archive the bad\r\n files to send them back to the client for invalid data issue.\r\n Output: None\r\n On Failure: OSError\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n now = datetime.now()\r\n date = now.date()\r\n time = now.strftime(\"%H%M%S\")\r\n try:\r\n\r\n source = 'Training_Raw_files_validated/Bad_Raw/'\r\n if os.path.isdir(source):\r\n path = \"TrainingArchiveBadData\"\r\n if not os.path.isdir(path):\r\n os.makedirs(path)\r\n dest = 'TrainingArchiveBadData/BadData_' + str(date)+\"_\"+str(time)\r\n if not os.path.isdir(dest):\r\n os.makedirs(dest)\r\n files = os.listdir(source)\r\n for f in files:\r\n if f not in os.listdir(dest):\r\n shutil.move(source + f, dest)\r\n file = open(\"Training_Logs/GeneralLog.txt\", 'a+')\r\n self.logger.log(file,\"Bad files moved to archive\")\r\n path = 'Training_Raw_files_validated/'\r\n if os.path.isdir(path + 'Bad_Raw/'):\r\n shutil.rmtree(path + 'Bad_Raw/')\r\n self.logger.log(file,\"Bad Raw Data Folder Deleted successfully!!\")\r\n file.close()\r\n except Exception as e:\r\n file = open(\"Training_Logs/GeneralLog.txt\", 'a+')\r\n self.logger.log(file, \"Error while moving bad files to archive:: %s\" % e)\r\n file.close()\r\n raise e\r\n\r\n\r\n\r\n\r\n def validationFileNameRaw(self,regex,LengthOfDateStampInFile,LengthOfTimeStampInFile):\r\n \"\"\"\r\n Method Name: validationFileNameRaw\r\n Description: This function validates the name of the training csv files as per given name in the schema!\r\n Regex pattern is used to do the validation.If name format do not match the file is moved\r\n to Bad Raw Data folder else in Good raw data.\r\n Output: None\r\n On Failure: Exception\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n\r\n\r\n # delete the directories for good and bad data in case last run was unsuccessful and folders were not deleted.\r\n self.deleteExistingBadDataTrainingFolder()\r\n self.deleteExistingGoodDataTrainingFolder()\r\n #create new directories\r\n self.createDirectoryForGoodBadRawData()\r\n onlyfiles = [f for f in listdir(self.Batch_Directory)]\r\n try:\r\n f = open(\"Training_Logs/nameValidationLog.txt\", 'a+')\r\n for filename in onlyfiles:\r\n if (re.match(regex, filename)):\r\n splitAtDot = re.split('.csv', filename)\r\n splitAtDot = (re.split('_', splitAtDot[0]))\r\n if len(splitAtDot[1]) == LengthOfDateStampInFile:\r\n if len(splitAtDot[2]) == LengthOfTimeStampInFile:\r\n shutil.copy(\"Training_Batch_Files/\" + filename, \"Training_Raw_files_validated/Good_Raw\")\r\n self.logger.log(f,\"Valid File name!! File moved to GoodRaw Folder :: %s\" % filename)\r\n\r\n else:\r\n shutil.copy(\"Training_Batch_Files/\" + filename, \"Training_Raw_files_validated/Bad_Raw\")\r\n self.logger.log(f,\"Invalid File Name!! File moved to Bad Raw Folder :: %s\" % filename)\r\n else:\r\n shutil.copy(\"Training_Batch_Files/\" + filename, \"Training_Raw_files_validated/Bad_Raw\")\r\n self.logger.log(f,\"Invalid File Name!! File moved to Bad Raw Folder :: %s\" % filename)\r\n else:\r\n shutil.copy(\"Training_Batch_Files/\" + filename, \"Training_Raw_files_validated/Bad_Raw\")\r\n self.logger.log(f, \"Invalid File Name!! File moved to Bad Raw Folder :: %s\" % filename)\r\n\r\n f.close()\r\n\r\n except Exception as e:\r\n f = open(\"Training_Logs/nameValidationLog.txt\", 'a+')\r\n self.logger.log(f, \"Error occured while validating FileName %s\" % e)\r\n f.close()\r\n raise e\r\n\r\n\r\n\r\n\r\n def validateColumnLength(self,NumberofColumns):\r\n \"\"\"\r\n Method Name: validateColumnLength\r\n Description: This function validates the number of columns in the csv files.\r\n It is should be same as given in the schema file.\r\n If not same file is not suitable for processing and thus is moved to Bad Raw Data folder.\r\n If the column number matches, file is kept in Good Raw Data for processing.\r\n\r\n Output: None\r\n On Failure: Exception\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n try:\r\n f = open(\"Training_Logs/columnValidationLog.txt\", 'a+')\r\n self.logger.log(f,\"Column Length Validation Started!!\")\r\n for file in listdir('Training_Raw_files_validated/Good_Raw/'):\r\n csv = pd.read_csv(\"Training_Raw_files_validated/Good_Raw/\" + file)\r\n if csv.shape[1] == NumberofColumns:\r\n pass\r\n else:\r\n shutil.move(\"Training_Raw_files_validated/Good_Raw/\" + file, \"Training_Raw_files_validated/Bad_Raw\")\r\n self.logger.log(f, \"Invalid Column Length for the file!! File moved to Bad Raw Folder :: %s\" % file)\r\n self.logger.log(f, \"Column Length Validation Completed!!\")\r\n except OSError:\r\n f = open(\"Training_Logs/columnValidationLog.txt\", 'a+')\r\n self.logger.log(f, \"Error Occured while moving the file :: %s\" % OSError)\r\n f.close()\r\n raise OSError\r\n except Exception as e:\r\n f = open(\"Training_Logs/columnValidationLog.txt\", 'a+')\r\n self.logger.log(f, \"Error Occured:: %s\" % e)\r\n f.close()\r\n raise e\r\n f.close()\r\n\r\n def validateMissingValuesInWholeColumn(self):\r\n \"\"\"\r\n Method Name: validateMissingValuesInWholeColumn\r\n Description: This function validates if any column in the csv file has all values missing.\r\n If all the values are missing, the file is not suitable for processing.\r\n SUch files are moved to bad raw data.\r\n Output: None\r\n On Failure: Exception\r\n\r\n Written By: iNeuron Intelligence\r\n Version: 1.0\r\n Revisions: None\r\n\r\n \"\"\"\r\n try:\r\n f = open(\"Training_Logs/missingValuesInColumn.txt\", 'a+')\r\n self.logger.log(f,\"Missing Values Validation Started!!\")\r\n\r\n for file in listdir('Training_Raw_files_validated/Good_Raw/'):\r\n csv = pd.read_csv(\"Training_Raw_files_validated/Good_Raw/\" + file)\r\n count = 0\r\n for columns in csv:\r\n if (len(csv[columns]) - csv[columns].count()) == len(csv[columns]):\r\n count+=1\r\n shutil.move(\"Training_Raw_files_validated/Good_Raw/\" + file,\r\n \"Training_Raw_files_validated/Bad_Raw\")\r\n self.logger.log(f,\"Invalid Column for the file!! File moved to Bad Raw Folder :: %s\" % file)\r\n break\r\n if count==0:\r\n csv.rename(columns={\"Unnamed: 0\": \"Wafer\"}, inplace=True)\r\n csv.to_csv(\"Training_Raw_files_validated/Good_Raw/\" + file, index=None, header=True)\r\n except OSError:\r\n f = open(\"Training_Logs/missingValuesInColumn.txt\", 'a+')\r\n self.logger.log(f, \"Error Occured while moving the file :: %s\" % OSError)\r\n f.close()\r\n raise OSError\r\n except Exception as e:\r\n f = open(\"Training_Logs/missingValuesInColumn.txt\", 'a+')\r\n self.logger.log(f, \"Error Occured:: %s\" % e)\r\n f.close()\r\n raise e\r\n f.close()\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n"
] | [
[
"pandas.read_csv"
]
] |
inqlee0704/pyqct | [
"304612ed558e7c46fe987ecfea8145cbc5721700"
] | [
"QCT/get_S_norm.py"
] | [
"# ##############################################################################\n# Usage: python get_S_norm.py Subj I1 I2\n# Time: ~ 20s\n# Ref: \n# ##############################################################################\n# 20220118, In Kyu Lee\n# No version suffix\n# ##############################################################################\n# v1c: 08/11/2021, In Kyu Lee\n# - Fixed: when V_IN < V_EX, s_norm returns nan issue.\n# - ownpow is used\n# v1b: 08/10/2021, In Kyu Lee\n# - S* stat is added\n# 03/18/2021, In Kyu Lee\n# Calculate S*\n# ##############################################################################\n# Input: \n# - displacement img, ex) PMSN03001_EX0-TO-PMSN03001_IN0-SSTVD_disp_resample.mhd'\n# - IN lobe mask, ex) PMSN03001_IN0_vida-lobes.img\n# Output:\n# - s* image, ex) PMSN03001_EX0-TO-PMSN03001_IN0-SSTVD_s_norm.img\n# - s* stat, ex) PMSN03001_EX0-TO-PMSN03001_IN0-SSTVD_lobar_s_norm.txt\n# ##############################################################################w\n\n# import libraries\nimport os\nimport sys\nimport numpy as np\nimport time\nimport pandas as pd\nfrom medpy.io import load, save\nimport SimpleITK as sitk\nsitk.ProcessObject_SetGlobalWarningDisplay(False)\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\ndef ownpow(a, b):\n if a > 0:\n return a**b\n if a < 0:\n temp = abs(a)**b\n return -1*temp\n\nstart = time.time()\nSubj = str(sys.argv[1]) # PMSN03001\nI1 = str(sys.argv[2]) # 'IN0'\nI2 = str(sys.argv[3]) # 'EX0'\n\ndisp_path = f'{Subj}_{I2}-TO-{Subj}_{I1}-SSTVD_disp_resample.mhd'\nhisto_EX = pd.read_csv(f'{Subj}_{I2}_vida-histo.csv')\nhisto_IN = pd.read_csv(f'{Subj}_{I1}_vida-histo.csv')\ns_norm_stat_path = f'{Subj}_{I2}-TO-{Subj}_{I1}-SSTVD_lobar_s_norm.txt'\n\nIN_lobe_path = f'{Subj}_{I1}_vida-lobes.img'\nif not os.path.exists(IN_lobe_path):\n IN_lobe_path = f'{Subj}_{I1}_vida-lobes.img.gz'\n\ns_norm_img_path = f'{Subj}_{I2}-TO-{Subj}_{I1}-SSTVD_s_norm.img'\n# V_cm3_IN \nV_EX = histo_EX.loc[histo_EX.location=='both', 'total-volume-cm3'].values[0]\nV_IN = histo_IN.loc[histo_IN.location=='both', 'total-volume-cm3'].values[0]\n# cm^3 -> mm^3\nV_EX = V_EX * 1000\nV_IN = V_IN * 1000\n\n# Data Loading . . .\ndisp, disp_h = load(disp_path)\nIN_lobe_img, IN_lobe_header = load(IN_lobe_path)\ns_norm_h = disp_h\n# [mm]\ns = (disp[:,:,:,0]**2+disp[:,:,:,1]**2+disp[:,:,:,2]**2)**0.5\n# This doesn't work if V_IN- V_EX is negative\n# s_norm = s/((V_IN-V_EX)**(1/3))\ns_norm = s/ownpow(V_IN-V_EX,1/3)\n\n# Prep stat\ns_norm_l0 = np.mean(s_norm[IN_lobe_img==8])\ns_norm_l1 = np.mean(s_norm[IN_lobe_img==16])\ns_norm_l2 = np.mean(s_norm[IN_lobe_img==32])\ns_norm_l3 = np.mean(s_norm[IN_lobe_img==64])\ns_norm_l4 = np.mean(s_norm[IN_lobe_img==128])\ns_norm_mean = (s_norm_l0 + s_norm_l1 + s_norm_l2 + s_norm_l3 + s_norm_l4)/5\n\ns_norm_l0_sd = np.std(s_norm[IN_lobe_img==8])\ns_norm_l1_sd = np.std(s_norm[IN_lobe_img==16])\ns_norm_l2_sd = np.std(s_norm[IN_lobe_img==32])\ns_norm_l3_sd = np.std(s_norm[IN_lobe_img==64])\ns_norm_l4_sd = np.std(s_norm[IN_lobe_img==128])\ns_norm_sd = np.std(s_norm[IN_lobe_img!=0])\n\n# CV = std/mean\ns_norm_l0_cv = s_norm_l0_sd/s_norm_l0\ns_norm_l1_cv = s_norm_l1_sd/s_norm_l1\ns_norm_l2_cv = s_norm_l2_sd/s_norm_l2\ns_norm_l3_cv = s_norm_l3_sd/s_norm_l3\ns_norm_l4_cv = s_norm_l4_sd/s_norm_l4\ns_norm_cv = s_norm_sd/s_norm_mean\n\ns_norm_stat = pd.DataFrame({'Lobes':['Lobe0','Lobe1','Lobe2','Lobe3','Lobe4','All'],\n 'sStar_m':np.float16([s_norm_l0,s_norm_l1,s_norm_l2,s_norm_l3,s_norm_l4,s_norm_mean]),\n 'sStar_sd':np.float16([s_norm_l0_sd,s_norm_l1_sd,s_norm_l2_sd,s_norm_l3_sd,s_norm_l4_sd,s_norm_sd]),\n 'sStar_cv':np.float16([s_norm_l0_cv,s_norm_l1_cv,s_norm_l2_cv,s_norm_l3_cv,s_norm_l4_cv,s_norm_cv])})\n\n\n# Save\nsave(s_norm,s_norm_img_path,hdr=s_norm_h)\ns_norm_stat.to_csv(s_norm_stat_path, index=False, sep=' ')\nend = time.time()\nprint(f'Elapsed time: {end-start}s')\n"
] | [
[
"numpy.std",
"pandas.read_csv",
"numpy.float16",
"numpy.mean"
]
] |
a-maumau/pixel_objectness.pytorch | [
"f5acb972be694662d839b99eb33e66a807d6031e"
] | [
"trainer.py"
] | [
"import os\nimport math\nimport argparse\nfrom datetime import datetime\n\nimport torch \nimport torch.nn as nn\nimport torch.nn.functional as F\n\nimport numpy as np\nfrom tqdm import tqdm\nfrom PIL import Image\n\nimport data_loader\nfrom mau_ml_util.train_logger import TrainLogger\n#from mau_ml_util.metric import SegmentationMetric\nfrom metric_from_latest_mmu import SegmentationMetric\nfrom templates import Template_Trainer\n\ntorch.backends.cudnn.benchmark = True\n\nclass ColorMap(object):\n def __init__(self, base_color=[[0,0,1], [0,1,1], [0,1,0], [1,1,0], [1,0,0]]):\n \"\"\"\n color_points: list of [int, int, int]\n each value of component represent R,G,B.\n \"\"\"\n\n self.base_color = base_color\n self.num_color_min1 = len(self.base_color)-1\n\n def __call__(self, val):\n return self.to_colormap(val)\n\n def to_colormap(self, val):\n \"\"\"\n returns tpule of (R,G,B) value in range [0,1].\n \"\"\"\n\n fract_between = 0\n\n if val <= 0:\n idx1 = idx2 = 0\n elif val >= 1:\n idx1 = idx2 = self.num_color_min1\n else:\n val = val * (self.num_color_min1)\n idx1 = math.floor(val);\n idx2 = idx1+1;\n fract_between = val - idx1\n \n r = (self.base_color[idx2][0] - self.base_color[idx1][0])*fract_between + self.base_color[idx1][0]\n g = (self.base_color[idx2][1] - self.base_color[idx1][1])*fract_between + self.base_color[idx1][1]\n b = (self.base_color[idx2][2] - self.base_color[idx1][2])*fract_between + self.base_color[idx1][2]\n\n return (r,g,b) \n\nclass Trainer_PixelObjectness(Template_Trainer):\n def __init__(self, args, model, optimizer, lr_policy):\n self.args = args \n self.lr_policy = lr_policy\n self.iter_wise = self.lr_policy.iteration_wise\n\n # for loggin the training\n val_head = [\"iter\" if self.iter_wise else \"epoch\", \"mean_pixel_accuracy\"]\n for i in range(self.args.class_num):\n val_head.append(\"mean_precision_class_{}\".format(i))\n for i in range(self.args.class_num):\n val_head.append(\"mean_IoU_class_{}\".format(i))\n self.tlog = self.get_train_logger({\"train\":[\"iter\" if self.iter_wise else \"epoch\", \"batch_mean_total_loss\"], \"val\":val_head},\n save_dir=self.args.save_dir, save_name=self.args.save_name, arguments=self.get_argparse_arguments(self.args),\n use_http_server=self.args.use_http_server, use_msg_server=self.args.use_msg_server, notificate=False,\n visualize_fetch_stride=self.args.viz_fetch_stride, http_port=self.args.http_server_port, msg_port=self.args.msg_server_port)\n \n\n\n # paths\n self.save_dir = self.tlog.log_save_path\n self.model_param_dir = self.tlog.mkdir(\"model_param\")\n\n if torch.cuda.is_available() and not self.args.nogpu:\n self.map_device = torch.device('cuda:{}'.format(self.args.gpu_device_num))\n else:\n self.map_device = torch.device('cpu')\n\n self.model = model\n if torch.cuda.is_available() and not args.nogpu:\n self.model = self.model.to(self.map_device)\n\n self.optimizer = optimizer\n\n self.train_loader = data_loader.get_train_loader(self.args, [(0.5, 0.5, 0.5),(0.5, 0.5, 0.5)])#[(0.485, 0.456, 0.406),(0.229, 0.224, 0.225)])\n self.val_loader = data_loader.get_val_loader(self.args, [(0.5, 0.5, 0.5),(0.5, 0.5, 0.5)])\n\n self.cmap = self._gen_cmap()\n\n if self.args.show_parameters:\n for idx, m in enumerate(model.modules()):\n print(idx, '->', m)\n print(args)\n\n print(\"\\nsaving at {}\\n\".format(self.save_dir))\n\n # PASCAL VOC color maps\n # borrowed from https://gist.github.com/wllhf/a4533e0adebe57e3ed06d4b50c8419ae\n def _gen_cmap_voc(self, class_num=255):\n def bitget(byteval, idx):\n return ((byteval & (1 << idx)) != 0)\n\n cmap = np.zeros((class_num+1, 3), dtype='uint8')\n for i in range(class_num+1):\n r = g = b = 0\n c = i\n for j in range(8):\n r = r | (bitget(c, 0) << 7-j)\n g = g | (bitget(c, 1) << 7-j)\n b = b | (bitget(c, 2) << 7-j)\n c = c >> 3\n\n cmap[i] = np.array([r, g, b])\n\n return cmap\n\n def _gen_cmap(self, max_value=255):\n mapper = ColorMap()\n cmap = []\n\n for v in range(max_value+1):\n cmap.append(np.uint8(np.array(mapper(v/max_value))*255))\n\n return cmap\n\n def convert_to_color_map(self, img_array, color_map=None, class_num=255):\n \"\"\"\n img_array: numpy.ndarray\n shape must be (width, height)\n \"\"\"\n\n if color_map is None:\n color_map = self._gen_cmap()\n\n new_img = np.empty(shape=(img_array.shape[0], img_array.shape[1], 3), dtype='uint8')\n\n for c in range(class_num+1):\n index = np.where(img_array == c)\n new_img[index] = color_map[c]\n\n return new_img\n\n def validate(self, count):\n with torch.no_grad():\n self.model.eval()\n\n # logging\n pix_acc = 0.0\n precision_class = []\n jaccard_class = []\n\n #data_count_precision = [0 for i in range(self.args.class_num)]\n #data_count_jaccard = [0 for i in range(self.args.class_num)]\n \n metric = SegmentationMetric(self.args.class_num, map_device=self.map_device)\n\n if self.args.quiet:\n _trainval_loader = self.val_loader\n else:\n _trainval_loader = self.to_tqdm(self.val_loader, desc=\"train val\")\n\n for b, (image, mask, original_image) in enumerate(_trainval_loader):\n batch_size = image.shape[0]\n\n img = self.format_tensor(image, requires_grad=False, map_device=self.map_device)\n mask = self.format_tensor(mask, requires_grad=False, map_device=self.map_device)\n\n outputs, prob_maps = self.model.inference(img)\n outputs = F.interpolate(outputs, size=[self.args.crop_size, self.args.crop_size], mode='bilinear', align_corners=False)\n prob_maps = F.interpolate(prob_maps, size=[self.args.crop_size, self.args.crop_size], mode='bilinear', align_corners=False)\n\n metric(outputs, mask)\n \n # save only few batch for sample\n if b < 1:\n self.tlog.setup_output(\"{}_{}_batch_{}_sample\".format(\"iter\" if self.iter_wise else \"epoch\", count, b))\n\n # test color image\n #test_img = np.ones((256,256))\n #for i in range(256):\n # test_img[i] = test_img[i]*i\n # \n #self.tlog.pack_output(Image.fromarray(self.convert_to_color_map(np.uint8(test_img))))\n \n for n in range(batch_size):\n self.tlog.pack_output(Image.fromarray(np.uint8(original_image[n].detach().numpy())))\n\n pred_img = np.uint8(outputs[n].squeeze(0).cpu().detach().numpy())\n prob_img = prob_maps[n].squeeze(0).cpu().detach().numpy()\n self.tlog.pack_output(Image.fromarray(pred_img*255), not_in_schema=True)\n self.tlog.pack_output(Image.fromarray(self.convert_to_color_map(np.uint8(prob_img[1]*255), self.cmap)))\n\n gt_img = np.uint8(mask[n].cpu().detach().numpy())\n self.tlog.pack_output(Image.fromarray(gt_img*255), not_in_schema=True)\n\n self.tlog.pack_output(None, \" \")\n\n self.tlog.pack_output(None, \"validation sample\", [\"left: input\", \"center: pred cmap\", \"right: output mask\"])\n self.tlog.flush_output()\n\n pix_acc = metric.calc_pix_acc()\n precision = metric.calc_mean_precision()\n jaccard_index = metric.calc_mean_jaccard_index()\n\n # might I should return the non evaluated class with nan and filter the list\n # by filter(lambda n: n!=float(\"nan\"), items)\n\n for class_id in range(self.args.class_num):\n precision_class.append(precision[\"class_{}\".format(class_id)])\n jaccard_class.append(jaccard_index[\"class_{}\".format(class_id)])\n\n #data_count_precision[class_id] += len(precision[\"class_{}\".format(str(class_id))])\n #data_count_jaccard[class_id] += len(jaccard_index[\"class_{}\".format(str(class_id))])\n\n # logging, this implementation is not caring missing value\n #mean_precision_classes = [y/x if x > 0 else 0 for y, x in zip(precision_class, data_count_precision)]\n #mean_iou_classes = [y/x if x > 0 else 0 for y, x in zip(jaccard_class, data_count_jaccard)]\n \n # clac. with out background\n log_msg_data = [count, pix_acc, np.mean(precision_class[1:]), np.mean(jaccard_class[1:])]\n\n self.tlog.log(\"val\", [count, pix_acc]+precision_class+jaccard_class)\n self.tlog.log_message(\"[{}] mean pix acc.:{:.5f}, precision:{:.5f}, IoU:{:.5f}\".format(*log_msg_data), \"LOG\", \"validation\")\n\n if not self.args.quiet:\n tqdm.write(\"[{}] mean pix acc.:{:.5f}, precision:{:.5f}, IoU:{:.5f}\".format(*log_msg_data))\n\n self.model.train()\n\n def train(self):\n train_finish = False\n \n if self.args.quiet:\n epochs = range(1, self.args.epochs+1)\n else:\n epochs = self.to_tqdm(range(1, self.args.epochs+1), desc=\"train\")\n\n curr_iter = 0\n epoch = 0\n\n total_loss = 0.0\n data_num = 0\n\n # for epoch wise and iter wise\n decay_arg = {\"curr_iter\":curr_iter, \"curr_epoch\":epoch}\n\n for epoch in epochs:\n if not self.iter_wise:\n total_loss = 0.0\n data_num = 0\n\n if self.args.quiet:\n _train_loader = self.train_loader\n else:\n _train_loader = self.to_tqdm(self.train_loader)\n\n for img, mask in _train_loader:\n # loss log will be showed in size averaged\n data_num += 1\n\n self.optimizer.zero_grad()\n\n images = self.format_tensor(img, map_device=self.map_device)\n masks = self.format_tensor(mask, map_device=self.map_device)\n\n output = self.model(images)\n output = F.interpolate(output, size=[self.args.crop_size, self.args.crop_size], mode='bilinear', align_corners=False)\n\n batch_loss = self.model.loss(output, masks)\n total_loss += batch_loss.item()\n \n batch_loss.backward()\n self.optimizer.step()\n\n curr_iter += 1\n\n if not self.args.quiet:\n _train_loader.set_description(\"{: 3d}: train[{}] loss: {:.5f}\".format(curr_iter if self.iter_wise else epoch, self.args.save_name, total_loss/data_num))\n\n if self.iter_wise:\n self.lr_policy.decay_lr(**decay_arg)\n \n if curr_iter % self.args.trainval_every == 0:\n self.validate(curr_iter)\n\n if curr_iter % self.args.save_every == 0:\n state = {'iter': curr_iter,\n 'optimizer_state_dict' : self.optimizer.state_dict()}\n self.model.save(add_state=state, file_name=os.path.join(self.model_param_dir,'model_param_iter{}.pth'.format(curr_iter)))\n \n self.tlog.log_message(\"[iter:{}] model saved.\".format(curr_iter), \"LOG\", \"train\")\n\n if curr_iter % self.args.log_every == 0:\n if not self.args.quiet:\n tqdm.write(\"[#{: 3d}] {} iter mean loss: {:.5f}\".format(curr_iter, self.args.log_every, total_loss/data_num))\n \n self.tlog.log(\"train\", [curr_iter, float(total_loss/data_num)])\n self.tlog.log_message(\"[{}] {} iter mean loss:{:.5f}\".format(\"iter:{}\".format(curr_iter), self.args.log_every, float(total_loss/data_num)), \"LOG\", \"train\")\n\n total_loss = 0\n data_num = 0\n\n if curr_iter == self.args.max_iter:\n train_finish = True\n _train_loader.close()\n break\n \n if train_finish:\n epochs.close()\n break\n\n if not self.iter_wise:\n if not self.args.quiet:\n tqdm.write(\"[# {: 3d}] batch mean loss: {:.5f}\".format(epoch, total_loss/data_num))\n \n if epoch % self.args.log_every == 0:\n self.tlog.log(\"train\", [epoch, float(total_loss/data_num)])\n self.tlog.log_message(\"[{}] batch mean loss:{:.5f}\".format(\"epoch:{}\".format(epoch), float(total_loss/data_num)), \"LOG\", \"train\")\n\n # check train validation\n if epoch % self.args.trainval_every == 0:\n self.validate(epoch)\n\n self.lr_policy.decay_lr(**decay_arg)\n #if epoch % self.args.decay_every == 0:\n # for param_group in self.optimizer.param_groups:\n # param_group['lr'] *= self.args.decay_value\n #\n # self.tlog.log_message(\"[epoch:{}] decay learning rate by {}\".format(epoch, self.args.decay_value), \"LOG\", \"train\")\n \n # save model\n if epoch % self.args.save_every == 0:\n state = {'epoch': epoch,\n 'optimizer_state_dict' : self.optimizer.state_dict()}\n self.model.save(add_state=state, file_name=os.path.join(self.model_param_dir,'model_param_e{}.pth'.format(epoch)))\n \n self.tlog.log_message(\"[epoch:{}] model saved.\".format(epoch), \"LOG\", \"train\")\n\n self.model.save(add_state={'optimizer_state_dict' : self.optimizer.state_dict()},\n file_name=os.path.join(self.model_param_dir, 'model_param_fin_{}.pth'.format(datetime.now().strftime(\"%Y%m%d_%H-%M-%S\"))))\n\n print(\"data is saved at {}\".format(self.save_dir))\n\n def test_loader(self):\n from matplotlib import pylab as plt\n import time\n\n if self.args.quiet:\n epochs = range(1, self.args.epochs+1)\n else:\n epochs = self.to_tqdm(range(1, self.args.epochs+1), desc=\"train\")\n\n for epoch in epochs:\n if self.args.quiet:\n _train_loader = self.train_loader\n else:\n _train_loader = self.to_tqdm(self.train_loader)\n\n for img, mask in _train_loader:\n batch_size = img.shape[0]\n\n img = img.numpy()\n mask = mask.numpy()\n\n for i in range(batch_size):\n _img = np.uint8(img[i]*255).transpose(1,2,0)\n _mask = self.convert_to_color_map(np.uint8(mask[i]), self.cmap)\n\n merged_img = np.concatenate([_img, _mask], axis=1)\n\n plt.imshow(merged_img)\n plt.show()\n\n"
] | [
[
"numpy.concatenate",
"torch.device",
"numpy.array",
"numpy.uint8",
"numpy.empty",
"numpy.zeros",
"torch.no_grad",
"torch.nn.functional.interpolate",
"numpy.mean",
"matplotlib.pylab.show",
"numpy.where",
"torch.cuda.is_available",
"matplotlib.pylab.imshow"
]
] |
solad5/acgan-gpt2 | [
"52901a996fd235355f8c3f6b83037c85b1fdb415",
"52901a996fd235355f8c3f6b83037c85b1fdb415"
] | [
"gpt2_model.py",
"embedders.py"
] | [
"'''\n code by TaeHwan Jung(@graykode)\n Original Paper and repository here : https://github.com/openai/gpt-2\n GPT2 Pytorch Model : https://github.com/huggingface/pytorch-pretrained-BERT\n'''\n\nimport copy\nimport torch\nimport math\nimport torch.nn as nn\nfrom torch.nn.parameter import Parameter\n\ndef gelu(x):\n return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))\n\ndef load_weight(model, state_dict):\n old_keys = []\n new_keys = []\n for key in state_dict.keys():\n new_key = None\n if key.endswith(\".g\"):\n new_key = key[:-2] + \".weight\"\n elif key.endswith(\".b\"):\n new_key = key[:-2] + \".bias\"\n elif key.endswith(\".w\"):\n new_key = key[:-2] + \".weight\"\n if new_key:\n old_keys.append(key)\n new_keys.append(new_key)\n for old_key, new_key in zip(old_keys, new_keys):\n state_dict[new_key] = state_dict.pop(old_key)\n\n missing_keys = []\n unexpected_keys = []\n error_msgs = []\n # copy state_dict so _load_from_state_dict can modify it\n metadata = getattr(state_dict, \"_metadata\", None)\n state_dict = state_dict.copy()\n if metadata is not None:\n state_dict._metadata = metadata\n\n def load(module, prefix=\"\"):\n local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {})\n module._load_from_state_dict(\n state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs\n )\n for name, child in module._modules.items():\n if child is not None:\n load(child, prefix + name + \".\")\n\n start_model = model\n if hasattr(model, \"transformer\") and all(not s.startswith('transformer.') for s in state_dict.keys()):\n start_model = model.transformer\n load(start_model, prefix=\"\")\n\n # Make sure we are still sharing the output and input embeddings after loading weights\n model.set_tied()\n return model\n\nclass LayerNorm(nn.Module):\n def __init__(self, hidden_size, eps=1e-12):\n \"\"\"Construct a layernorm module in the TF style (epsilon inside the square root).\n \"\"\"\n super(LayerNorm, self).__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.bias = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = eps\n\n def forward(self, x):\n u = x.mean(-1, keepdim=True)\n s = (x - u).pow(2).mean(-1, keepdim=True)\n x = (x - u) / torch.sqrt(s + self.variance_epsilon)\n return self.weight * x + self.bias\n\n\nclass Conv1D(nn.Module):\n def __init__(self, nf, nx):\n super(Conv1D, self).__init__()\n self.nf = nf\n w = torch.empty(nx, nf)\n nn.init.normal_(w, std=0.02)\n self.weight = Parameter(w)\n self.bias = Parameter(torch.zeros(nf))\n\n def forward(self, x):\n size_out = x.size()[:-1] + (self.nf,)\n x = torch.addmm(self.bias, x.view(-1, x.size(-1)), self.weight)\n x = x.view(*size_out)\n return x\n\n\nclass Attention(nn.Module):\n def __init__(self, nx, n_ctx, config, scale=False):\n super(Attention, self).__init__()\n n_state = nx # in Attention: n_state=768 (nx=n_embd)\n # [switch nx => n_state from Block to Attention to keep identical to TF implem]\n assert n_state % config.n_head == 0\n self.register_buffer(\"bias\", torch.tril(torch.ones(n_ctx, n_ctx)).view(1, 1, n_ctx, n_ctx))\n self.n_head = config.n_head\n self.split_size = n_state\n self.scale = scale\n self.c_attn = Conv1D(n_state * 3, nx)\n self.c_proj = Conv1D(n_state, nx)\n\n def _attn(self, q, k, v):\n w = torch.matmul(q, k)\n if self.scale:\n w = w / math.sqrt(v.size(-1))\n nd, ns = w.size(-2), w.size(-1)\n b = self.bias[:, :, ns - nd:ns, :ns]\n # Here the bias b also serves as the mask to remove future information\n w = w * b - 1e10 * (1 - b)\n w = nn.Softmax(dim=-1)(w)\n return torch.matmul(w, v)\n\n def merge_heads(self, x):\n x = x.permute(0, 2, 1, 3).contiguous()\n new_x_shape = x.size()[:-2] + (x.size(-2) * x.size(-1),)\n return x.view(*new_x_shape) # in Tensorflow implem: fct merge_states\n\n def split_heads(self, x, k=False):\n new_x_shape = x.size()[:-1] + (self.n_head, x.size(-1) // self.n_head)\n x = x.view(*new_x_shape) # in Tensorflow implem: fct split_states\n if k:\n return x.permute(0, 2, 3, 1) # (batch, head, head_features, seq_length)\n else:\n return x.permute(0, 2, 1, 3) # (batch, head, seq_length, head_features)\n\n def forward(self, x, layer_past=None):\n x = self.c_attn(x)\n query, key, value = x.split(self.split_size, dim=2)\n query = self.split_heads(query)\n key = self.split_heads(key, k=True)\n value = self.split_heads(value)\n if layer_past is not None:\n past_key, past_value = layer_past[0].transpose(-2, -1), layer_past[1] # transpose back cf below\n key = torch.cat((past_key, key), dim=-1)\n value = torch.cat((past_value, value), dim=-2)\n present = torch.stack((key.transpose(-2, -1), value)) # transpose to have same shapes for stacking\n a = self._attn(query, key, value)\n a = self.merge_heads(a)\n a = self.c_proj(a)\n return a, present\n\n\nclass MLP(nn.Module):\n def __init__(self, n_state, config): # in MLP: n_state=3072 (4 * n_embd)\n super(MLP, self).__init__()\n nx = config.n_embd\n self.c_fc = Conv1D(n_state, nx)\n self.c_proj = Conv1D(nx, n_state)\n self.act = gelu\n\n def forward(self, x):\n h = self.act(self.c_fc(x))\n h2 = self.c_proj(h)\n return h2\n\n\nclass Block(nn.Module):\n def __init__(self, n_ctx, config, scale=False):\n super(Block, self).__init__()\n nx = config.n_embd\n self.ln_1 = LayerNorm(nx, eps=config.layer_norm_epsilon)\n self.attn = Attention(nx, n_ctx, config, scale)\n self.ln_2 = LayerNorm(nx, eps=config.layer_norm_epsilon)\n self.mlp = MLP(4 * nx, config)\n\n def forward(self, x, layer_past=None):\n a, present = self.attn(self.ln_1(x), layer_past=layer_past)\n x = x + a\n m = self.mlp(self.ln_2(x))\n x = x + m\n return x, present\n\n\nclass Transformer(nn.Module):\n def __init__(self, config):\n super().__init__()\n self.n_layer = config.n_layer\n self.n_embd = config.n_embd\n self.n_vocab = config.vocab_size\n\n self.wte = nn.Embedding(config.vocab_size, config.n_embd)\n self.wpe = nn.Embedding(config.n_positions, config.n_embd)\n block = Block(config.n_ctx, config, scale=True)\n self.h = nn.ModuleList([copy.deepcopy(block) for _ in range(config.n_layer)])\n self.ln_f = LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)\n\n def set_embeddings_weights(self, model_embeddings_weights):\n embed_shape = model_embeddings_weights.shape\n self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)\n self.decoder.weight = model_embeddings_weights # Tied weights\n\n def forward(self, input_ids, position_ids=None, token_type_ids=None, past=None):\n if past is None:\n past_length = 0\n past = [None] * len(self.h)\n else:\n past_length = past[0][0].size(-2)\n if position_ids is None:\n position_ids = torch.arange(past_length, input_ids.size(-1) + past_length, dtype=torch.long,\n device=input_ids.device)\n position_ids = position_ids.unsqueeze(0).expand_as(input_ids)\n\n input_shape = input_ids.size()\n input_ids = input_ids.view(-1, input_ids.size(-1))\n position_ids = position_ids.view(-1, position_ids.size(-1))\n\n inputs_embeds = self.wte(input_ids)\n position_embeds = self.wpe(position_ids)\n if token_type_ids is not None:\n token_type_ids = token_type_ids.view(-1, token_type_ids.size(-1))\n token_type_embeds = self.wte(token_type_ids)\n else:\n token_type_embeds = 0\n hidden_states = inputs_embeds + position_embeds + token_type_embeds\n presents = []\n for block, layer_past in zip(self.h, past):\n hidden_states, present = block(hidden_states, layer_past)\n presents.append(present)\n hidden_states = self.ln_f(hidden_states)\n output_shape = input_shape + (hidden_states.size(-1),)\n return hidden_states.view(*output_shape), presents\n\n\nclass LinearReadoutHead(nn.Module):\n def __init__(self, model_embeddings_weights, config):\n super().__init__()\n self.n_embd = config.n_embd\n self.set_embeddings_weights(model_embeddings_weights)\n\n def set_embeddings_weights(self, model_embeddings_weights):\n embed_shape = model_embeddings_weights.shape\n self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)\n self.decoder.weight = model_embeddings_weights # Tied weights\n\n def forward(self, hidden_state):\n # Truncated Language modeling logits (we remove the last token)\n # h_trunc = h[:, :-1].contiguous().view(-1, self.n_embd)\n lm_logits = self.decoder(hidden_state)\n return lm_logits\n\n\nclass GPT2(nn.Module):\n def __init__(self, config):\n super().__init__()\n self.transformer = Transformer(config)\n self.readout_head = LinearReadoutHead(self.transformer.wte.weight, config)\n\n def set_tied(self):\n \"\"\" Make sure we are sharing the embeddings\n \"\"\"\n self.readout_head.set_embeddings_weights(self.transformer.wte.weight)\n\n def forward(self, input_ids, position_ids=None, token_type_ids=None, past=None):\n hidden_states, presents = self.transformer(input_ids, position_ids, token_type_ids, past)\n return hidden_states",
"from transformers import *\nimport pdb\nfrom torch.nn.utils import weight_norm as wn\nfrom tqdm import tqdm\nfrom torch.nn.utils.rnn import pad_sequence\nimport torch.nn as nn\nimport torch\nfrom bpe_encoder import get_codec\nfrom gpt2_model import GPT2\nfrom utils import parse_config\n\ndef bert_encoder():\n return BERTEncoder()\n\ndef gpt2_encoder():\n return GPT2Encoder()\n\ndef class_embedding(n_classes, embedding_dim):\n return nn.Embedding(n_classes, embedding_dim)\n\n\ndef unconditional(n_classes, embedding_dim):\n return nn.Embedding(n_classes, embedding_dim)\n\n\nclass Embedder(nn.Module):\n def __init__(self, embed_size):\n super(Embedder, self).__init__()\n self.embed_size = embed_size\n\n def forward(self, class_labels, captions):\n raise NotImplementedError\n\n\nclass BERTEncoder(Embedder):\n '''\n pretrained model used to embed text to a 768 dimensional vector\n '''\n\n def __init__(self):\n super(BERTEncoder, self).__init__(embed_size=768)\n self.pretrained_weights = 'bert-base-uncased'\n self.tokenizer = BertTokenizer.from_pretrained(self.pretrained_weights)\n self.model = BertModel.from_pretrained(self.pretrained_weights)\n self.max_len = 50\n\n def tokenize(self, text_batch):\n text_token_ids = [\n torch.tensor(self.tokenizer.encode(string_, add_special_tokens=False, max_length=self.max_len)) for\n string_ in text_batch]\n padded_input = pad_sequence(text_token_ids, batch_first=True, padding_value=0)\n return padded_input\n\n def forward(self, class_labels, captions):\n '''\n :param class_labels : torch.LongTensor, class ids\n :param list captions: list of strings, sentences to embed\n :return: torch.tensor embeddings: embeddings of shape (batch_size,embed_size=768)\n '''\n\n padded_input = self.tokenize(captions)\n device = list(self.parameters())[0].device\n padded_input = padded_input.to(device)\n # takes the mean of the last hidden states computed by the pre-trained BERT encoder and return it\n return self.model(padded_input)[0].mean(dim=1)\n\n\nclass GPT2Encoder(Embedder):\n '''\n pretrained model used to embed text to a 768 dimensional vector\n '''\n def __init__(self):\n super(GPT2Encoder, self).__init__(embed_size=768)\n self.codec = get_codec()\n self.gpt2_config = parse_config()\n self.gpt2_model = GPT2(self.gpt2_config)\n\n def forward(self, class_labels, captions):\n '''\n :param class_labels: torch.LongTensor, class ids\n :param list captions: list of strings, sentences to embed\n :return: torch.tensor embeddings: embeddungs of shape (batch_size, embed_size=768)\n '''\n count = 0\n for caption in captions:\n curembedding = self.gpt2_model(self.codec.encode(caption))\n curembedding = torch.mean(curembedding, dim=1)\n if count == 0:\n res = curembedding\n count += 1\n else:\n res = torch.cat((res, curembedding), dim=0)\n return res\n"
] | [
[
"torch.nn.Linear",
"torch.zeros",
"torch.cat",
"torch.sqrt",
"torch.nn.Softmax",
"torch.ones",
"torch.nn.init.normal_",
"torch.empty",
"torch.matmul",
"torch.nn.Embedding",
"torch.nn.parameter.Parameter",
"torch.pow"
],
[
"torch.nn.utils.rnn.pad_sequence",
"torch.cat",
"torch.mean",
"torch.nn.Embedding"
]
] |
ManuLado/Enviar-comandos-a-marlin | [
"5ba596c9b0db47125e2e29ed8084e61d326e8777",
"5ba596c9b0db47125e2e29ed8084e61d326e8777"
] | [
"take_images.py",
"pano_libs/P0.py"
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# Graba video leido desde la arducam\n# Se le debe indicar el archivo de video a grabar y\n# la duración de la captura en segundos.\n\n# SINTAXIS: python capturar_video.py VIDEO TIEMPO\n# 1- Ruta del video\n# 2- Tiempo de grabacion en segundos\n\nfrom ctypes import *\n\nimport ctypes\n\nimport sys\nimport os\n\nimport time\nfrom PIL import Image\nimport numpy as np\nimport thread as thread\nimport math\n\nfrom select import select\nfrom evdev import InputDevice\nfrom evdev import ecodes\nfrom astropy.io import fits\nimport ArducamSDK\n\n# Analisis de argumentos\nif (len(sys.argv)==3):\n NOMBREIMG = sys.argv[1];\n NUMIMG = int(sys.argv[2]);\nelse:\n print (\"Se requieren 2 argumentos: NOMBRE_IMAGENES NUMERO_IMAGENES\")\n exit()\n\n#### CONFIGURACION ARDUCAMSDK ################\nCOLOR_BYTE2RGB = 47 # No se modifico del original\nCAMERA_MT9M001 = 0x4D091031 # No se modifico del original\nSensorShipAddr = 186\nI2C_MODE_8_16 = 1\nusbVid = 0x52CB # No se modifico del original\nWidth = 1280 #1280\nHeight = 1024 #1024\ncfg ={\"u32CameraType\":CAMERA_MT9M001,\n \"u32Width\":Width,\"u32Height\":Height,\n \"u32UsbVersion\":1,\n \"u8PixelBytes\":1,\n \"u16Vid\":0x52cb,\n \"u8PixelBits\":8,\n \"u32SensorShipAddr\":SensorShipAddr,\n \"emI2cMode\":I2C_MODE_8_16 }\n\n# FLAGS\nglobal saveFlag,downFlag,flag,H_value,V_value,lx,ly,mx,my,dx,dy,W_zoom,H_zooM,handle,openFlag,initTime,storeFlag,bufferData,globalGain\nglobal testPatternFlag\nglobal integrationTime\nglobal shutterWidth\n\nopenFlag = False\nhandle = {}\ndownFlag = False\nflag = True\nsaveFlag = False\nstoreFlag = False\nsaveNum=0\nH_value = 0\nV_value = 0\nW_zoom = 0\nH_zoom = 0\nlx = 0\nly = 0\nmx = 0\nmy = 0\ndx = 0\ndy = 0\ntestPatternFlag = False;\n\nregArr=[[0x01, 0x000C], # Row Start\n [0x02, 0x0014], # Column Start\n [0x03, Height - 1], # Window Height 0x03FF\n [0x04, Width - 1], # Window Width 0x04FF\n [0x05, 0x0009], # Horizontal Blanking\n [0x06, 0x0019], # Vertical Blanking\n [0x07, 0x0002], # Output Control\n [0x09, 0x0419], # Shutter Width 0x0419 (max: 0x3FFF)\n [0x0B, 0x0000], # Frame Restart\n [0x0C, 0x0000],#0x0100], \n [0x0D, 0x0000], \n [0x1E, 0x8000], # Read Mode 1 0x8000\n [0x20, 0x1104], \n [0x2B, 0x0008], \n [0x2C, 0x0008], \n [0x2D, 0x0008], \n [0x2E, 0x0008],\n [0x32, 0x0FFC], # Test Data Register\n [0x35, 0x0067], # Global Gain 0x0008 (max: 0x0067)\n [0x5F, 0x0904], \n #[0x60, 0x0000], # BLC offset: Even row, even column\n #[0x61, 0x0000], # BLC offset: Odd row, odd column\n #[0x62, 0x049F], # Black Level Calibration Control 0x0498 (No-BLC: 0x049F; Manual-BLC: 0x0499 & reg0x60/61/63/64)\n #[0x63, 0x0000], # BLC offset: Even row, odd column\n #[0x64, 0x0000], # BLC offset: Odd row, Even column\n [0x60, 0x002F], # BLC offset: Even row, even column\n [0x61, 0x002F], # BLC offset: Odd row, odd column\n [0x62, 0x0499], # Black Level Calibration Control 0x0498 (No-BLC: 0x049F; Manual-BLC: 0x0499 & reg0x60/61/63/64)\n [0x63, 0x000F], # BLC offset: Even row, odd column\n [0x64, 0x000F], # BLC offset: Odd row, Even column\n [0xF1, 0x0001], \n [0xFFFF, 0xFFFF]\n]\n\nglobalGain = regArr[18][1];\n\n# Cálculo del tiempo de integración inicial (pag 16 del datasheet)\nrowTime = regArr[3][1] + 1 + 244 + regArr[4][1] - 19; #[pixel clock periods] default: 1514\nresetDelay = 4*regArr[9][1] #[pixel clock periods] default: 0\noverheadTime = 180; #[pixel clock periods]\nshutterWidth = regArr[7][1]\nintegrationPeriods = shutterWidth*rowTime - overheadTime - resetDelay;\nclockPeriod = 1000.0/24e6; #[ms]\nintegrationTime = integrationPeriods * clockPeriod; #[ms]\nwith open('integrationtime.txt','w') as it:\n it.write(str(integrationTime)+\"\\n\")\n\nprint (\"Initial integration time: %.3fms\"%(integrationTime));\nprint (\"Initial gain: 0x%02x\"%(globalGain));\n\na_lock = thread.allocate_lock();\n\ndef readThread(threadName,read_Flag):\n global flag,handle,storeFlag,bufferData,openFlag\n global a_lock\n count = 0\n time0 = time.time()\n time1 = time.time()\n data = {}\n # Wait for the arducam object to be ready\n while openFlag == False:\n time1 = time.time();\n if time1 - time0 > 20:\n #timeout\n exit;\n\n while flag:\n res = ArducamSDK.Py_ArduCam_available(handle)\n #~ print \"Available frames %d\"%(res)\n if res > 0:\n \n res,data = ArducamSDK.Py_ArduCam_read(handle,Width * Height)\n if res == 0:\n count += 1\n time1 = time.time()\n ArducamSDK.Py_ArduCam_del(handle)\n else:\n print (\"read data fail!\")\n \n else:\n #print \"No data availiable\"\n time.sleep(.01);\n \n if len(data) >= Width * Height:\n if time1 - time0 >= 5:\n print (\"%s %f %s\\n\"%(\"fps:\",count*1.0/(time1-time0),\"/s\"))\n count = 0\n time0 = time1\n \n a_lock.acquire();\n bufferData = data;\n data = [];\n storeFlag = True;\n a_lock.release();\n #show(data)\n\t\t#else:\n\t\t#\tprint \"data length is not enough!\"\n if flag == False:\n break\n \nthread.start_new_thread( readThread,(\"Thread-2\", flag,))\n\npass\n\ndef showAndSave(threadName,algoquenoseusa):\n global flag,W_zoom,H_zoom,V_value,H_value,lx,ly,downFlag,saveFlag,saveNum,bufferData,storeFlag\n global a_lock\n global hist_ax\n global NOMBREIMG\n img = np.zeros((Height, Width), dtype=np.uint8);\n while flag:\n a_lock.acquire();\n if storeFlag == True:\n storeFlag = False;\n img = np.frombuffer(bufferData, np.uint8)\n img = np.reshape(img, (Height, Width));\n\n saveNum += 1\n #name = NOMBREIMG + str(saveNum) + \".fits\"\n\t #name = NOMBREIMG + \"_\" + str(saveNum) + \".jpeg\"\n name = NOMBREIMG + \".fits\"\n hdu=fits.PrimaryHDU()\n hdu.data=img\n hdu.writeto(name,overwrite=True)\n print (\"Frame saved to %s\"%(name))\n \n a_lock.release();\n \n if saveNum == NUMIMG:\n flag=False;\n print (\"Total number of adq images = %d\"%(saveNum))\n \n if flag == False:\n break\nthread.start_new_thread( showAndSave,(\"Thread-3\",flag))\npass\n\ndef init_and_read_arducam():\n\tglobal flag,regArr,handle,openFlag\n\tregNum = 0\n\tres,handle = ArducamSDK.Py_ArduCam_autoopen(cfg)\n\tif res == 0:\n\t\topenFlag = True\n\t\tprint (\"device open success!\")\n\t\twhile (regArr[regNum][0] != 0xFFFF):\n\t\t\tArducamSDK.Py_ArduCam_writeSensorReg(handle,regArr[regNum][0],regArr[regNum][1])\n\t\t\tregNum = regNum + 1\n\t\tres = ArducamSDK.Py_ArduCam_beginCapture(handle)\n\t\t\n\t\tif res == 0:\n\t\t\tprint (\"transfer task create success!\")\n\t\t\twhile flag :\t\t\n\t\t\t\tres = ArducamSDK.Py_ArduCam_capture(handle)\n\t\t\t\tif res != 0:\n\t\t\t\t\tprint (\"capture failed!\")\n\t\t\t\t\tflag = False;\n\t\t\t\t\tbreak;\t\t\t\t\t\n\t\t\t\ttime.sleep(0.1)\n\t\t\t\tif flag == False:\t\t\n\t\t\t\t\tbreak\n\t\telse:\n\t\t\tprint (\"transfer task create fail!\")\n\t\t\n\t\ttime.sleep(2);\n\t\tres = ArducamSDK.Py_ArduCam_close(handle)\n\t\tif res == 0:\n\t\t\topenFlag = False\n\t\t\tprint (\"device close success!\")\n\t\telse:\n\t\t\tprint (\"device close fail!\")\n\telse:\n\t\tprint (\"device open fail!\")\n\nif __name__ == \"__main__\":\n\tinitTime = time.time();\n\tinit_and_read_arducam();\n\n",
"from random import randrange\r\nimport matplotlib.pyplot as plt\r\nimport numpy as np\r\nimport cv2\r\nimport argparse\r\nparser = argparse.ArgumentParser()\r\nparser.add_argument(\"echo\", help=\"echo the string you use here\")\r\nparser.add_argument(\"nombre1\", help=\"echo the string you use here\")\r\nparser.add_argument(\"nombre2\", help=\"echo the string you use here\")\r\nparser.add_argument(\"nombre3\", help=\"echo the string you use here\")\r\nargs = parser.parse_args()\r\n\r\ndire=args.echo\r\n\r\n\r\nname1=dire+'/'+args.nombre1\r\nname2=dire+'/'+args.nombre2\r\nk=args.nombre3\r\n\r\nfigsize = (10, 10)\r\nrgb_l = cv2.cvtColor(cv2.imread(name1), cv2.COLOR_BGR2RGB)\r\ngray_l = cv2.cvtColor(rgb_l, cv2.COLOR_RGB2GRAY)\r\nrgb_r = cv2.cvtColor(cv2.imread(name2), cv2.COLOR_BGR2RGB)\r\ngray_r = cv2.cvtColor(rgb_r, cv2.COLOR_RGB2GRAY)\r\n# use orb if sift is not installed\r\nfeature_extractor = cv2.ORB_create()\r\n\r\n# find the keypoints and descriptors with chosen feature_extractor\r\nkp_l, desc_l = feature_extractor.detectAndCompute(gray_l, None)\r\nkp_r, desc_r = feature_extractor.detectAndCompute(gray_r, None)\r\n\r\ntest = cv2.drawKeypoints(rgb_l, kp_l, None, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)\r\n\r\nplt.figure(figsize=figsize)\r\nplt.imshow(test)\r\nplt.title(\"keypoints\")\r\n#plt.show()\r\nbf = cv2.BFMatcher()\r\nmatches = bf.knnMatch(desc_l, desc_r, k=2)\r\n\r\n# Apply ratio test\r\ngood_match = []\r\nfor m in matches:\r\n if m[0].distance/m[1].distance < 0.5:\r\n good_match.append(m)\r\ngood_match_arr = np.asarray(good_match)\r\n\r\n# show only 30 matches\r\nim_matches = cv2.drawMatchesKnn(rgb_l, kp_l, rgb_r, kp_r,\r\n good_match[0:30], None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)\r\n\r\nplt.figure(figsize=(20, 20))\r\nplt.imshow(im_matches)\r\nplt.title(\"keypoints matches\")\r\n#plt.show()\r\ngood_kp_l = np.array([kp_l[m.queryIdx].pt for m in good_match_arr[:, 0]]).reshape(-1, 1, 2)\r\ngood_kp_r = np.array([kp_r[m.trainIdx].pt for m in good_match_arr[:, 0]]).reshape(-1, 1, 2)\r\nH, masked = cv2.findHomography(good_kp_r, good_kp_l, cv2.RANSAC, 5.0)\r\n\r\nprint(H)\r\nrgb_r_warped = cv2.warpPerspective(rgb_r, H, (rgb_l.shape[1] + rgb_r.shape[1], rgb_l.shape[0]))\r\nrgb_r_warped[0:rgb_l.shape[0], 0:rgb_l.shape[1]] = rgb_l\r\n\r\nplt.figure(figsize=figsize)\r\nplt.imshow(rgb_r_warped)\r\nplt.title(\"naive warping\")\r\n#plt.show()\r\ndef warpTwoImages(img1, img2, H):\r\n '''warp img2 to img1 with homograph H\r\n from: https://stackoverflow.com/questions/13063201/how-to-show-the-whole-image-when-using-opencv-warpperspective\r\n '''\r\n h1, w1 = img1.shape[:2]\r\n h2, w2 = img2.shape[:2]\r\n pts1 = np.float32([[0, 0], [0, h1], [w1, h1], [w1, 0]]).reshape(-1, 1, 2)\r\n pts2 = np.float32([[0, 0], [0, h2], [w2, h2], [w2, 0]]).reshape(-1, 1, 2)\r\n pts2_ = cv2.perspectiveTransform(pts2, H)\r\n pts = np.concatenate((pts1, pts2_), axis=0)\r\n [xmin, ymin] = np.int32(pts.min(axis=0).ravel() - 0.5)\r\n [xmax, ymax] = np.int32(pts.max(axis=0).ravel() + 0.5)\r\n t = [-xmin, -ymin]\r\n Ht = np.array([[1, 0, t[0]], [0, 1, t[1]], [0, 0, 1]]) # translate\r\n\r\n result = cv2.warpPerspective(img2, Ht@H, (xmax-xmin, ymax-ymin))\r\n result[t[1]:h1+t[1], t[0]:w1+t[0]] = img1\r\n return result\r\n\r\n\r\nresult = warpTwoImages(rgb_l, rgb_r, H)\r\n\r\nplt.figure(figsize=figsize)\r\nplt.imshow(result)\r\nplt.title(\"better warping\")\r\n#plt.show()\r\ncv2.imwrite(dire+\"_P0/\"+str(k)+\".jpg\",result)"
] | [
[
"numpy.reshape",
"numpy.zeros",
"numpy.frombuffer"
],
[
"numpy.concatenate",
"numpy.array",
"numpy.asarray",
"matplotlib.pyplot.title",
"matplotlib.pyplot.figure",
"numpy.float32",
"matplotlib.pyplot.imshow"
]
] |
AndrewFalkowski/SODIS_SIM | [
"4d5da3e0872ee747d399d66fdee1633e7d2b8ab1"
] | [
"BoxThermal.py"
] | [
"import numpy as np\nfrom math import sqrt\nimport matplotlib.pyplot as plt\nimport numba\nimport time\nfrom scipy.integrate import odeint\n\n\n\n# a sample differential equation dy/dx = (x-y)/2\n\n# def dydx(x,y):\n# return ((x-y)/2)\n\n# # find the value of y for a given x using step size h\n# # and an initial value y0 at x0\n\n# def rungeKutta(x0, y0, x, h):\n# #count num iteratings using step size or step height h\n# n = int(((x - x0)/h))\n# # iterate for number of iterations\n# y = y0\n# for i in range(1, n + 1):\n# # apply runge kutta formulas to find the next value of y\n# k1 = h * dydx(x0, y)\n# k2 = h * dydx(x0 + 0.5 * h, y + 0.5 * k1)\n# k3 = h * dydx(x0 + 0.5 * h, y + 0.5 * k2)\n# k4 = h * dydx(x0 + h, y + k3)\n\n# # update the next value of y\n# y = y + (1.0 / 6.0) * (k1 + 2*k2 + 2*k3 + k4)\n\n# # update the next value of x\n# x0 = x0 + h\n\n# return y\n\n\n# # driver method\n# x0 = 0\n# y = 1\n# x = 2\n# h = 0.2\n# print('The value of y at x is:', rungeKutta(x0, y, x, h))\n\ndef box_dim(A_c, h, prct_f):\n # all dimensions in meters\n box_vol = A_c * h\n vol_f = box_vol * prct_f # L\n m_a = box_vol * (1-prct_f) * 1.225\n m_f = vol_f * 997 # kg\n print('Contained Water: ', m_f, 'Liters')\n A_s = 4 * h * np.sqrt(A_c)\n return m_f, m_a, A_s\n\n# m_f, m_a, A_s = box_dim(0.25, 0.15, 0.9)\n\n\ndef boxODE(x, t, m_f, m_a, A_s):\n\n # constants\n A_c = 0.25 # square meters\n A_s = A_s\n A_f = A_c # square meters\n T_amb = 298 # kelvin\n T_sky = T_amb - 6 # kelvin\n alpha_g = 0.02 # %\n alpha_p = 0.98\n t_g = 0.9 # %\n t_f = 0.85 # %\n # print(t)\n Irr = 0.0426*(t) + 1.38E-6*(t)**2 - 7.94E-11*(t)**3 + 7.3E-16*(t)**4\n # Irr = 600\n x_b = 0.065 # insulation thickness meters\n x_s = 0.065 # insulation thickness meters\n\n k_i = 1.0 # thermal conductivity of side materials, foamed glass # W/mK\n h_rad_g2_g1 = 8\n h_cov_g2_g1 = 20\n h_rad_g1_sky = 8\n h_rad_g1_amb = 8\n h_rad_p_g2 = 20\n h_cov_a_g2 = 8\n h_cov_f_a = 8\n h_cov_p_f = 30\n h_cov_g1_amb = 65\n\n M_f = m_f * 4.187\n M_g1 = 1150 * (A_c * 0.001) * 1.67 # assuming acrylic\n M_g2 = M_g1\n M_p = 8960 * (A_c * 0.065) * 1.0\n # assuming coper\n M_a = 0.718 * m_a\n\n # assign each ODE to a vector element\n T_g1 = x[0]\n T_g2 = x[1]\n T_a = x[2]\n T_p = x[3]\n T_f = x[4]\n\n Q_rad_g2_g1 = h_rad_g2_g1 * A_c * (T_g2 - T_g1)\n Q_cov_g2_g1 = h_cov_g2_g1 * A_c * (T_g2 - T_g1)\n Q_rad_g1_sky = h_rad_g1_sky * A_c * (T_g1 - T_sky)\n Q_cov_g1_amb = h_rad_g1_amb * A_c * (T_g1 - T_amb)\n Q_rad_p_g2 = h_rad_p_g2 * A_c * (T_p - T_g2)\n Q_cov_a_g2 = h_cov_a_g2 * A_c * (T_a - T_g2)\n Q_cov_f_a = h_cov_f_a * (A_c) * (T_f - T_a)\n Q_cov_p_f = h_cov_p_f * A_c * (T_p - T_f)\n U_base = ((x_b/k_i) + 1/(h_cov_g1_amb))**(-1)\n U_side = ((x_s/k_i) + 1/(h_cov_g1_amb))**(-1)\n Q_amb_loss = (U_base*A_c + U_side*A_s)*(T_p - T_amb)\n\n\n\n # define each ODE\n dT_g1dt = (Irr * alpha_g * A_c + Q_rad_g2_g1 + Q_cov_g2_g1 - Q_rad_g1_sky - Q_cov_g1_amb) / M_g1\n dT_g2dt = (Irr * alpha_g * t_g * A_c + Q_rad_p_g2 + Q_cov_a_g2 - Q_rad_g2_g1) / M_g2\n dT_adt = (Q_cov_f_a - Q_cov_a_g2)/M_a\n dT_pdt = (Irr * alpha_p * t_g**2 * t_f * A_c - Q_rad_p_g2 - Q_amb_loss - Q_cov_p_f) / M_p\n dT_fdt = (Q_cov_p_f + Q_cov_f_a) / M_f\n\n return [dT_g1dt, dT_g2dt, dT_adt, dT_pdt, dT_fdt]\n\n# x0 = [298, 298, 298, 298, 285]\n\n\n# # test the defined ODES\n# print(boxODE(x=x0, t=0, m_f=m_f, m_a=m_a, A_s=A_s))\n\n\n# # declare a time vector (time window)\n# t = np.linspace(0,54000,1000)\n# x = odeint(boxODE,x0,t, args=(m_f, m_a, A_s))\n\n# Tf= x[:,4]\n# Tp = x[:,3]\n\n# # plot the results\n# plt.plot((t/3600)+5.8,Tf_2, label='fluid')\n# # plt.plot(t/3600,Tp, label='plate')\n# plt.legend()\n# plt.ylim(298, 340)\n# plt.xlim(0,24)\n# plt.show()\n\n#%%\n\n# xs = np.arange(27000,28201,1)\n# ys = 0.0226*xs - 295\n\n# #%%\n\n# fig = plt.figure(figsize=(5,5))\n# fig, ax1 = plt.subplots()\n\n# plt.plot((t/3600)+5.8,Tf, color='r')\n# plt.plot(xs/3600 + 5.8, ys, color='r')\n# plt.plot(np.arange(27000,27601,1)/3600+5.8, )\n# plt.hlines(338, -100, 100, linestyle=':', color='k')\n# plt.text(6.5, 339, 'Pasteurization Temperature')\n\n# ax1.tick_params(direction='in', length=7,top=True, right=True, left=True)\n# minor_locator_x = AutoMinorLocator(2)\n# minor_locator_y = AutoMinorLocator(2)\n# ax1.get_xaxis().set_minor_locator(minor_locator_x)\n# ax1.get_yaxis().set_minor_locator(minor_locator_y)\n# # rotate and align the tick labels so they look better\n# plt.tick_params(which='minor',\n# direction='in',\n# length=4,\n# right=True,\n# left=True,\n# top=True)\n# plt.xlim(6,21)\n# plt.xlabel('Hour of Day')\n# plt.ylim(298, 350)\n# plt.ylabel('Water Temperature (K)')\n\n# plt.savefig('Figures/comb_img.png', dpi=300)"
] | [
[
"numpy.sqrt"
]
] |
rivei/pm4py_with_dash | [
"05ed524c11b44932783864a4465d400ea1300910"
] | [
"python/pm4pyPlus.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sun Dec 1 22:17:20 2019\n\n@author: Wei\n\"\"\"\n\n#from dash_app import default_log as log\nimport pandas as pd\nimport numpy as np\n#import pytz\nfrom datetime import datetime, tzinfo,timedelta\n\nfrom pm4py.statistics.traces.log import case_statistics\nfrom pm4py.algo.filtering.log.attributes import attributes_filter\n\nMAX_TRACES = 9999\n\ndef filtered_log_df(log, top_trace_n = MAX_TRACES):\n# if top_trace_n == MAX_TRACES:\n# traces_with_count = case_statistics.get_variant_statistics(log) #parameters=(\"max_variants_to_return\":5)\n# #df = pd.DataFrame.from_dict([dict(x) for x in traces_with_count])\n# df = pd.DataFrame()\n# df.columns = ['caseid','actid','actseq','resid','ts','sT']\n# else:\n n_cases = 0\n caseid = []\n actid = []\n actseq = []\n resid = []\n ts = []\n startTime = []\n for case in log:\n actidx = 0\n startT = case[0]['time:timestamp'].timestamp()\n for event in case:\n caseid.append(n_cases)\n actid.append(event['concept:name'])\n actseq.append(actidx)\n resid.append(event['org:resource'])\n ts.append(event['time:timestamp'].timestamp())\n startTime.append(event['time:timestamp'].timestamp() - startT)\n actidx = actidx + 1\n n_cases = n_cases + 1\n df = pd.DataFrame({'caseid': caseid, \n 'actid':actid, \n 'actseq':actseq, \n 'resid':resid, \n 'ts':ts, \n 'sT': startTime}) \n df['preid'] = df['actid'].shift(1)\n df['preid'] = df.apply(lambda row: row['preid'] if row['actseq']!=0 else 'START', axis = 1)\n\n return df\n\ndef n_cases(log, top_trace_n = MAX_TRACES):\n if top_trace_n == MAX_TRACES:\n df = filtered_log_df(log)\n else:\n df = filtered_log_df(log, top_trace_n)\n return len(df['caseid'].unique())\n \n\ndef n_events(log):\n df = filtered_log_df(log)\n return len(df)\n \ndef n_activities(log):\n df = filtered_log_df(log)\n return len(df['actid'].unique())\n\ndef n_resources(log):\n df = filtered_log_df(log)\n return len(df['resid'].unique())\n\ndef n_traces(log, top_trace_n = MAX_TRACES):\n if top_trace_n == MAX_TRACES:\n traces_with_count = case_statistics.get_variant_statistics(log) #parameters=(\"max_variants_to_return\":5)\n else:\n traces_with_count = case_statistics.get_variant_statistics(log, parameters={\"max_variants_to_return\":top_trace_n})\n \n df = pd.DataFrame.from_dict([dict(x) for x in traces_with_count])\n return len(df)\n\ndef acts_df(log):\n activities = attributes_filter.get_attribute_values(log, \"concept:name\")\n actid = []\n cnt = []\n for act0 in activities.items():\n actid.append(act0[0])\n cnt.append(act0[1]) \n return pd.DataFrame({'id':actid, 'cnt':cnt})\n\ndef traces_df(log):\n traces = case_statistics.get_variant_statistics(log) \n tid = []\n actid = []\n actseq = []\n cnt = []\n n_traces = 0\n for trace in traces:\n actidx = 0\n acts = trace['variant']\n for s in acts.split(','):\n tid.append(n_traces)\n actid.append(s)\n actseq.append(actidx)\n cnt.append(trace['count'])\n actidx = actidx+1\n n_traces = n_traces + 1\n \n trace_df = pd.DataFrame({'id': tid, 'actid': actid, 'actseq':actseq, 'cnt':cnt})\n trace_df['preid'] = trace_df['actid'].shift(1)\n trace_df['preid'] = trace_df.apply(lambda row: row['preid'] if row['actseq']!=0 else 'START', axis = 1) \n trace_df['pre_post'] = trace_df.apply(lambda row: row['preid']+\"@@\"+row['actid'], axis = 1)\n \n# def actid2num(sactid, df):\n# nactid = -1\n# for i in range(0, len(df)):\n# if df['id'][i] == sactid:\n# nactid = i/len(df)\n# return nactid\n# \n# act_df = acts_df(log)\n# trace_df['nactid'] = trace_df['actid'].apply(lambda i:actid2num(i, act_df))\n return trace_df\n \n \ndef sort_df(log):\n df = filtered_log_df(log) \n dur = np.zeros(len(df))\n evS = 0\n evE = -1\n for i in range(0, len(df)):\n if df['actseq'][i] == 0:\n evS = i\n if i < len(df) - 1:\n if df['actseq'][i + 1] == 0:\n evE = i\n else:\n evE = i\n \n if evE >= evS:\n for j in range(evS, evE+1):\n dur[j] = df['sT'][evE-1]\n\n df['dur'] = dur\n \n sort_df = df.sort_values(by=['dur','caseid', 'actseq'], ascending = [0,1,1])\n \n sortid = 0\n sid = np.zeros(len(sort_df))\n for i in range(1, len(sort_df)):\n if i < len(sort_df) - 1:\n if sort_df.iloc[i,:]['caseid'] != sort_df.iloc[i-1,:]['caseid']:\n sortid = sortid + 1\n \n sid[i] = sortid\n \n sort_df['sid'] = sid\n return sort_df\n\ndef mtx_df(log):\n df = traces_df(log)\n prelist = (df['preid'].unique())\n actlist = (df['actid'].unique())\n dff = pd.DataFrame(columns=prelist,index = actlist)\n# dff.columns = actlist\n# dff.index = prelist\n\n mtxdf1 = df.groupby('pre_post')['cnt'].sum() #agg(['sum','count','mean'])\n #mtxdf1['abs'] = mtxdf1['sum']/mtxdf1['count']\n# mtxdf= pd.DataFrame({'pre_post':mtxdf1.index, 'cnt': list(mtxdf1)})\n \n for s in mtxdf1.index:\n a = s.split(\"@@\")\n if len(a) != 2:\n print(a[0], a[1])\n else:\n dff[a[0]][a[1]] = mtxdf1[s]\n\n return dff\n \n#\n#activities = log_attributes_filter.get_attribute_values(log, \"concept:name\")\n#actid = []\n#cnt = []\n#for act0 in activities.items():\n# actid.append(act0[0])\n# cnt.append(act0[1])\n#\n#act_df = pd.DataFrame({'id':actid, 'cnt':cnt})\n#\n#n_activities = len(act_df)\n#\n#from pm4py.statistics.traces.log import case_statistics\n#traces = case_statistics.get_variant_statistics(log)#, parameters={\"max_variants_to_return\": 5})\n#\n##acts = []\n##cnt = []\n##tid = []\n##idx = 0\n##for trace in traces:\n## tid.append(idx)\n## acts.append(trace['variant'])\n## cnt.append(trace['count'])\n## idx = idx + 1\n## \n##trace_df = pd.DataFrame({'id': tid, 'acts': acts, 'cnt':cnt})\n##n_traces = len(trace_df)\n#\n#tid = []\n#actid = []\n#actseq = []\n#cnt = []\n#n_traces = 0\n#for trace in traces:\n# actidx = 0\n# acts = trace['variant']\n# for s in acts.split(','):\n# tid.append(n_traces)\n# actid.append(s)\n# actseq.append(actidx)\n# cnt.append(trace['count'])\n# actidx = actidx+1\n# n_traces = n_traces + 1\n# \n#trace_df = pd.DataFrame({'id': tid, 'actid': actid, 'actseq':actseq, 'cnt':cnt})\n#trace_df['preid'] = trace_df['actid'].shift(1)\n#trace_df['preid'] = trace_df.apply(lambda row: row['preid'] if row['actseq']!=0 else 'START', axis = 1)\n##trace_df['postid'] = trace_df['actid'].shift(1)\n##trace_df['postid'] = trace_df.apply(lambda row: row['preid'] if row['actseq']!=0 else 'START', axis = 1)\n#\n#trace_df['pre_post'] = trace_df.apply(lambda row: row['preid']+\"-\"+row['actid'], axis = 1)\n#\n#def actid2num(sactid, df):\n# nactid = -1\n# for i in range(0, len(df)):\n# if df['id'][i] == sactid:\n# nactid = i/len(df)\n# return nactid\n#\n##actid2num(\"Confirmation of receipt\", act_df)\n#\n#trace_df['nactid'] = trace_df['actid'].apply(lambda i:actid2num(i, act_df))\n#\n## matrix\n#df['pre_post'] = df.apply(lambda row: row['preid']+\"-\"+row['actid'], axis = 1)\n##mtxdf1 = pd.DataFrame({'ant':df['preid'],'con':df})\n#mtxdf1 = df[df['preid']!='START'].groupby('pre_post')['caseid'].count() #agg(['sum','count','mean'])\n##mtxdf1['abs'] = mtxdf1['sum']/mtxdf1['count']\n#mtxdf= pd.DataFrame({'pre_post':mtxdf1.index, 'cnt': list(mtxdf1)})\n#\n##roles Detection: related to resource vs activity?\n##from pm4py.algo.enhancement.roles import factory as roles_factory\n##roles = roles_factory.apply(log)\n#aaa\n"
] | [
[
"pandas.DataFrame"
]
] |
guptarohit994/ECE143_group25_project | [
"e31d0425b2a6114eed6c55bdb0491c2c996b94be"
] | [
"statistical_analysis/gpa_scatter.py"
] | [
"\nimport helper\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd \n\ndef plot_gpa_scatter():\n \"\"\"Plotting scatterplot of grades expected and grade received, using the general department list\n \"\"\"\n # obtaining data\n department_df = helper.generate_depts_df(helper.general_dept_list)\n comp_criteria = [\"AvgGradeExpected\",\"AvgGradeReceived\"]\n\n # generating scatterplot graph\n lower_bound = 1.5\n upper_bound = 4.02\n ax = department_df.plot.scatter(x=comp_criteria[0], y=comp_criteria[1], c= \"grey\",ylim=(lower_bound,upper_bound),xlim=(lower_bound,upper_bound), figsize=(10,10), fontsize=20, alpha = 0.3)\n ax.set_xlabel(\"Average Grade Expected\", fontsize = 20)\n ax.set_ylabel(\"Average Grade Received\", fontsize = 20)\n\n # computing least squares best fit line and adding it onto graph\n y = department_df[\"AvgGradeReceived\"]\n x = department_df[\"AvgGradeExpected\"]\n A = np.vstack([x, np.ones(len(x))]).T\n m, c = np.linalg.lstsq(A, y, rcond=None)[0]\n print(\"m:{}, c:{}\".format(m,c))\n ax.plot(np.linspace(lower_bound,4,10),np.linspace(lower_bound,4,10),c=\"red\")\n ax.plot(np.linspace(lower_bound,4,10),(np.linspace(lower_bound,4,10)*m) + c,c=\"blue\")"
] | [
[
"numpy.linspace",
"numpy.linalg.lstsq"
]
] |
AK391/stylegan_xl | [
"9854d3d0e96eccaad10cab22379c018e1e031cf0"
] | [
"viz/renderer.py"
] | [
"# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# NVIDIA CORPORATION and its licensors retain all intellectual property\n# and proprietary rights in and to this software, related documentation\n# and any modifications thereto. Any use, reproduction, disclosure or\n# distribution of this software and related documentation without an express\n# license agreement from NVIDIA CORPORATION is strictly prohibited.\n\nimport sys\nimport copy\nimport traceback\nimport numpy as np\nimport torch\nimport torch.fft\nimport torch.nn\nimport matplotlib.cm\nimport dnnlib\nfrom torch_utils.ops import upfirdn2d\nimport legacy # pylint: disable=import-error\n\n#----------------------------------------------------------------------------\n\nclass CapturedException(Exception):\n def __init__(self, msg=None):\n if msg is None:\n _type, value, _traceback = sys.exc_info()\n assert value is not None\n if isinstance(value, CapturedException):\n msg = str(value)\n else:\n msg = traceback.format_exc()\n assert isinstance(msg, str)\n super().__init__(msg)\n\n#----------------------------------------------------------------------------\n\nclass CaptureSuccess(Exception):\n def __init__(self, out):\n super().__init__()\n self.out = out\n\n#----------------------------------------------------------------------------\n\ndef _sinc(x):\n y = (x * np.pi).abs()\n z = torch.sin(y) / y.clamp(1e-30, float('inf'))\n return torch.where(y < 1e-30, torch.ones_like(x), z)\n\ndef _lanczos_window(x, a):\n x = x.abs() / a\n return torch.where(x < 1, _sinc(x), torch.zeros_like(x))\n\n#----------------------------------------------------------------------------\n\ndef _construct_affine_bandlimit_filter(mat, a=3, amax=16, aflt=64, up=4, cutoff_in=1, cutoff_out=1):\n assert a <= amax < aflt\n mat = torch.as_tensor(mat).to(torch.float32)\n\n # Construct 2D filter taps in input & output coordinate spaces.\n taps = ((torch.arange(aflt * up * 2 - 1, device=mat.device) + 1) / up - aflt).roll(1 - aflt * up)\n yi, xi = torch.meshgrid(taps, taps)\n xo, yo = (torch.stack([xi, yi], dim=2) @ mat[:2, :2].t()).unbind(2)\n\n # Convolution of two oriented 2D sinc filters.\n fi = _sinc(xi * cutoff_in) * _sinc(yi * cutoff_in)\n fo = _sinc(xo * cutoff_out) * _sinc(yo * cutoff_out)\n f = torch.fft.ifftn(torch.fft.fftn(fi) * torch.fft.fftn(fo)).real\n\n # Convolution of two oriented 2D Lanczos windows.\n wi = _lanczos_window(xi, a) * _lanczos_window(yi, a)\n wo = _lanczos_window(xo, a) * _lanczos_window(yo, a)\n w = torch.fft.ifftn(torch.fft.fftn(wi) * torch.fft.fftn(wo)).real\n\n # Construct windowed FIR filter.\n f = f * w\n\n # Finalize.\n c = (aflt - amax) * up\n f = f.roll([aflt * up - 1] * 2, dims=[0,1])[c:-c, c:-c]\n f = torch.nn.functional.pad(f, [0, 1, 0, 1]).reshape(amax * 2, up, amax * 2, up)\n f = f / f.sum([0,2], keepdim=True) / (up ** 2)\n f = f.reshape(amax * 2 * up, amax * 2 * up)[:-1, :-1]\n return f\n\n#----------------------------------------------------------------------------\n\ndef _apply_affine_transformation(x, mat, up=4, **filter_kwargs):\n _N, _C, H, W = x.shape\n mat = torch.as_tensor(mat).to(dtype=torch.float32, device=x.device)\n\n # Construct filter.\n f = _construct_affine_bandlimit_filter(mat, up=up, **filter_kwargs)\n assert f.ndim == 2 and f.shape[0] == f.shape[1] and f.shape[0] % 2 == 1\n p = f.shape[0] // 2\n\n # Construct sampling grid.\n theta = mat.inverse()\n theta[:2, 2] *= 2\n theta[0, 2] += 1 / up / W\n theta[1, 2] += 1 / up / H\n theta[0, :] *= W / (W + p / up * 2)\n theta[1, :] *= H / (H + p / up * 2)\n theta = theta[:2, :3].unsqueeze(0).repeat([x.shape[0], 1, 1])\n g = torch.nn.functional.affine_grid(theta, x.shape, align_corners=False)\n\n # Resample image.\n y = upfirdn2d.upsample2d(x=x, f=f, up=up, padding=p)\n z = torch.nn.functional.grid_sample(y, g, mode='bilinear', padding_mode='zeros', align_corners=False)\n\n # Form mask.\n m = torch.zeros_like(y)\n c = p * 2 + 1\n m[:, :, c:-c, c:-c] = 1\n m = torch.nn.functional.grid_sample(m, g, mode='nearest', padding_mode='zeros', align_corners=False)\n return z, m\n\n#----------------------------------------------------------------------------\n\nclass Renderer:\n def __init__(self):\n self._device = torch.device('cuda')\n self._pkl_data = dict() # {pkl: dict | CapturedException, ...}\n self._networks = dict() # {cache_key: torch.nn.Module, ...}\n self._pinned_bufs = dict() # {(shape, dtype): torch.Tensor, ...}\n self._cmaps = dict() # {name: torch.Tensor, ...}\n self._is_timing = False\n self._start_event = torch.cuda.Event(enable_timing=True)\n self._end_event = torch.cuda.Event(enable_timing=True)\n self._net_layers = dict() # {cache_key: [dnnlib.EasyDict, ...], ...}\n\n def render(self, **args):\n self._is_timing = True\n self._start_event.record(torch.cuda.current_stream(self._device))\n res = dnnlib.EasyDict()\n try:\n self._render_impl(res, **args)\n except:\n res.error = CapturedException()\n self._end_event.record(torch.cuda.current_stream(self._device))\n if 'image' in res:\n res.image = self.to_cpu(res.image).numpy()\n if 'stats' in res:\n res.stats = self.to_cpu(res.stats).numpy()\n if 'error' in res:\n res.error = str(res.error)\n if self._is_timing:\n self._end_event.synchronize()\n res.render_time = self._start_event.elapsed_time(self._end_event) * 1e-3\n self._is_timing = False\n return res\n\n def get_network(self, pkl, key, **tweak_kwargs):\n data = self._pkl_data.get(pkl, None)\n if data is None:\n print(f'Loading \"{pkl}\"... ', end='', flush=True)\n try:\n with dnnlib.util.open_url(pkl, verbose=False) as f:\n data = legacy.load_network_pkl(f)\n print('Done.')\n except:\n data = CapturedException()\n print('Failed!')\n self._pkl_data[pkl] = data\n self._ignore_timing()\n if isinstance(data, CapturedException):\n raise data\n\n orig_net = data[key]\n cache_key = (orig_net, self._device, tuple(sorted(tweak_kwargs.items())))\n net = self._networks.get(cache_key, None)\n if net is None:\n try:\n net = copy.deepcopy(orig_net)\n net = self._tweak_network(net, **tweak_kwargs)\n net.to(self._device)\n except:\n net = CapturedException()\n self._networks[cache_key] = net\n self._ignore_timing()\n if isinstance(net, CapturedException):\n raise net\n return net\n\n def _tweak_network(self, net):\n # Print diagnostics.\n #for name, value in misc.named_params_and_buffers(net):\n # if name.endswith('.magnitude_ema'):\n # value = value.rsqrt().numpy()\n # print(f'{name:<50s}{np.min(value):<16g}{np.max(value):g}')\n # if name.endswith('.weight') and value.ndim == 4:\n # value = value.square().mean([1,2,3]).sqrt().numpy()\n # print(f'{name:<50s}{np.min(value):<16g}{np.max(value):g}')\n return net\n\n def _get_pinned_buf(self, ref):\n key = (tuple(ref.shape), ref.dtype)\n buf = self._pinned_bufs.get(key, None)\n if buf is None:\n buf = torch.empty(ref.shape, dtype=ref.dtype).pin_memory()\n self._pinned_bufs[key] = buf\n return buf\n\n def to_device(self, buf):\n return self._get_pinned_buf(buf).copy_(buf).to(self._device)\n\n def to_cpu(self, buf):\n return self._get_pinned_buf(buf).copy_(buf).clone()\n\n def _ignore_timing(self):\n self._is_timing = False\n\n def _apply_cmap(self, x, name='viridis'):\n cmap = self._cmaps.get(name, None)\n if cmap is None:\n cmap = matplotlib.cm.get_cmap(name)\n cmap = cmap(np.linspace(0, 1, num=1024), bytes=True)[:, :3]\n cmap = self.to_device(torch.from_numpy(cmap))\n self._cmaps[name] = cmap\n hi = cmap.shape[0] - 1\n x = (x * hi + 0.5).clamp(0, hi).to(torch.int64)\n x = torch.nn.functional.embedding(x, cmap)\n return x\n\n def _render_impl(self, res,\n pkl = None,\n w0_seeds = [[0, 1]],\n stylemix_idx = [],\n stylemix_seed = 0,\n trunc_psi = 1,\n trunc_cutoff = 0,\n random_seed = 0,\n noise_mode = 'const',\n force_fp32 = False,\n layer_name = None,\n sel_channels = 3,\n base_channel = 0,\n img_scale_db = 0,\n img_normalize = False,\n fft_show = False,\n fft_all = True,\n fft_range_db = 50,\n fft_beta = 8,\n input_transform = None,\n untransform = False,\n ):\n # Dig up network details.\n G = self.get_network(pkl, 'G_ema')\n res.img_resolution = G.img_resolution\n res.num_ws = G.num_ws\n res.has_noise = any('noise_const' in name for name, _buf in G.synthesis.named_buffers())\n res.has_input_transform = (hasattr(G.synthesis, 'input') and hasattr(G.synthesis.input, 'transform'))\n\n # Set input transform.\n if res.has_input_transform:\n m = np.eye(3)\n try:\n if input_transform is not None:\n m = np.linalg.inv(np.asarray(input_transform))\n except np.linalg.LinAlgError:\n res.error = CapturedException()\n G.synthesis.input.transform.copy_(torch.from_numpy(m))\n\n # Generate random latents.\n all_seeds = [seed for seed, _weight in w0_seeds] + [stylemix_seed]\n all_seeds = list(set(all_seeds))\n all_zs = np.zeros([len(all_seeds), G.z_dim], dtype=np.float32)\n all_cs = np.zeros([len(all_seeds), G.c_dim], dtype=np.float32)\n for idx, seed in enumerate(all_seeds):\n rnd = np.random.RandomState(seed)\n all_zs[idx] = rnd.randn(G.z_dim)\n cls = rnd.randint(G.c_dim)\n if G.c_dim > 0:\n all_cs[idx, cls] = 1\n\n # Run mapping network.\n w_avg = G.mapping.w_avg[cls]\n all_zs = self.to_device(torch.from_numpy(all_zs))\n all_cs = self.to_device(torch.from_numpy(all_cs))\n all_ws = G.mapping(z=all_zs, c=all_cs, truncation_psi=trunc_psi, truncation_cutoff=trunc_cutoff) - w_avg\n all_ws = dict(zip(all_seeds, all_ws))\n\n # Calculate final W.\n w = torch.stack([all_ws[seed] * weight for seed, weight in w0_seeds]).sum(dim=0, keepdim=True)\n stylemix_idx = [idx for idx in stylemix_idx if 0 <= idx < G.num_ws]\n if len(stylemix_idx) > 0:\n w[:, stylemix_idx] = all_ws[stylemix_seed][np.newaxis, stylemix_idx]\n w += w_avg\n\n # Run synthesis network.\n synthesis_kwargs = dnnlib.EasyDict(noise_mode=noise_mode, force_fp32=force_fp32)\n torch.manual_seed(random_seed)\n out, layers = self.run_synthesis_net(G.synthesis, w, capture_layer=layer_name, **synthesis_kwargs)\n\n # Update layer list.\n cache_key = (G.synthesis, tuple(sorted(synthesis_kwargs.items())))\n if cache_key not in self._net_layers:\n if layer_name is not None:\n torch.manual_seed(random_seed)\n _out, layers = self.run_synthesis_net(G.synthesis, w, **synthesis_kwargs)\n self._net_layers[cache_key] = layers\n res.layers = self._net_layers[cache_key]\n\n # Untransform.\n if untransform and res.has_input_transform:\n out, _mask = _apply_affine_transformation(out.to(torch.float32), G.synthesis.input.transform, amax=6) # Override amax to hit the fast path in upfirdn2d.\n\n # Select channels and compute statistics.\n out = out[0].to(torch.float32)\n if sel_channels > out.shape[0]:\n sel_channels = 1\n base_channel = max(min(base_channel, out.shape[0] - sel_channels), 0)\n sel = out[base_channel : base_channel + sel_channels]\n res.stats = torch.stack([\n out.mean(), sel.mean(),\n out.std(), sel.std(),\n out.norm(float('inf')), sel.norm(float('inf')),\n ])\n\n # Scale and convert to uint8.\n img = sel\n if img_normalize:\n img = img / img.norm(float('inf'), dim=[1,2], keepdim=True).clip(1e-8, 1e8)\n img = img * (10 ** (img_scale_db / 20))\n img = (img * 127.5 + 128).clamp(0, 255).to(torch.uint8).permute(1, 2, 0)\n res.image = img\n\n # FFT.\n if fft_show:\n sig = out if fft_all else sel\n sig = sig.to(torch.float32)\n sig = sig - sig.mean(dim=[1,2], keepdim=True)\n sig = sig * torch.kaiser_window(sig.shape[1], periodic=False, beta=fft_beta, device=self._device)[None, :, None]\n sig = sig * torch.kaiser_window(sig.shape[2], periodic=False, beta=fft_beta, device=self._device)[None, None, :]\n fft = torch.fft.fftn(sig, dim=[1,2]).abs().square().sum(dim=0)\n fft = fft.roll(shifts=[fft.shape[0] // 2, fft.shape[1] // 2], dims=[0,1])\n fft = (fft / fft.mean()).log10() * 10 # dB\n fft = self._apply_cmap((fft / fft_range_db + 1) / 2)\n res.image = torch.cat([img.expand_as(fft), fft], dim=1)\n\n @staticmethod\n def run_synthesis_net(net, *args, capture_layer=None, **kwargs): # => out, layers\n submodule_names = {mod: name for name, mod in net.named_modules()}\n unique_names = set()\n layers = []\n\n def module_hook(module, _inputs, outputs):\n outputs = list(outputs) if isinstance(outputs, (tuple, list)) else [outputs]\n outputs = [out for out in outputs if isinstance(out, torch.Tensor) and out.ndim in [4, 5]]\n for idx, out in enumerate(outputs):\n if out.ndim == 5: # G-CNN => remove group dimension.\n out = out.mean(2)\n name = submodule_names[module]\n if name == '':\n name = 'output'\n if len(outputs) > 1:\n name += f':{idx}'\n if name in unique_names:\n suffix = 2\n while f'{name}_{suffix}' in unique_names:\n suffix += 1\n name += f'_{suffix}'\n unique_names.add(name)\n shape = [int(x) for x in out.shape]\n dtype = str(out.dtype).split('.')[-1]\n layers.append(dnnlib.EasyDict(name=name, shape=shape, dtype=dtype))\n if name == capture_layer:\n raise CaptureSuccess(out)\n\n hooks = [module.register_forward_hook(module_hook) for module in net.modules()]\n try:\n out = net(*args, **kwargs)\n except CaptureSuccess as e:\n out = e.out\n for hook in hooks:\n hook.remove()\n return out, layers\n\n#----------------------------------------------------------------------------\n"
] | [
[
"torch.stack",
"torch.cuda.Event",
"torch.meshgrid",
"torch.nn.functional.pad",
"torch.nn.functional.affine_grid",
"torch.fft.fftn",
"torch.cuda.current_stream",
"numpy.eye",
"torch.manual_seed",
"torch.kaiser_window",
"torch.zeros_like",
"torch.as_tensor",
"torch.empty",
"torch.device",
"torch.nn.functional.embedding",
"numpy.asarray",
"torch.sin",
"numpy.random.RandomState",
"torch.arange",
"torch.from_numpy",
"torch.nn.functional.grid_sample",
"torch.ones_like",
"numpy.linspace"
]
] |
jggatter/cumulus | [
"1dfd9dfce5a44ff867859db6f24a356f72c6ccdd"
] | [
"docker/demultiplexing/demuxlet/generate_zarr.py"
] | [
"import argparse\n\nimport pegasusio as pio\nimport pandas as pd\n\nparser = argparse.ArgumentParser(description='Merge demuxlet result with gene-count matrix.')\nparser.add_argument('demux_res', metavar = 'demux_result.best', help = 'Demuxlet demultiplexing results.')\nparser.add_argument('raw_mat', metavar = 'raw_feature_bc_matrix.h5', help = 'Raw gene count matrix in 10x format.')\nparser.add_argument('out_file', metavar = 'output_result.zarr', help = 'Output zarr file.')\nargs = parser.parse_args()\n\ndemux_type_dict = {'SNG': 'singlet', 'DBL': 'doublet', 'AMB': 'unknown'}\n\ndef write_output(assignment_file: str, input_mat_file: str, output_zarr_file: str) -> None:\n df = pd.read_csv(assignment_file, sep = '\\t', header = 0, index_col = 'BARCODE')\n df.index = pd.Index([x[:-2] for x in df.index])\n df['demux_type'] = df['DROPLET.TYPE'].apply(lambda s: demux_type_dict[s])\n df['assignment'] = ''\n df.loc[df['demux_type'] == 'singlet', 'assignment'] = df.loc[df['demux_type'] == 'singlet', 'SNG.BEST.GUESS']\n df.loc[df['demux_type'] == 'doublet', 'assignment'] = df.loc[df['demux_type'] == 'doublet', 'DBL.BEST.GUESS'].apply(lambda s: ','.join(s.split(',')[:-1]))\n\n data = pio.read_input(input_mat_file)\n data.obs['demux_type'] = ''\n data.obs['assignment'] = ''\n\n idx = data.obs_names.isin(df.index)\n barcodes = data.obs_names[idx]\n df_valid = df.loc[barcodes, ['demux_type', 'assignment']]\n data.obs.loc[idx, 'demux_type'] = df_valid['demux_type'].values\n data.obs.loc[idx, 'assignment'] = df_valid['assignment'].values\n\n pio.write_output(data, output_zarr_file, zarr_zipstore = True)\n\n\nif __name__ == '__main__':\n write_output(args.demux_res, args.raw_mat, args.out_file)"
] | [
[
"pandas.read_csv",
"pandas.Index"
]
] |
HuangHaoyu1997/gym-miniworld | [
"77dc24bf1b1ca8c2cfefadfe3e35a0deb2d08a1a",
"77dc24bf1b1ca8c2cfefadfe3e35a0deb2d08a1a"
] | [
"gym_miniworld/miniworld.py",
"gym_miniworld/entity.py"
] | [
"import math\nfrom enum import IntEnum\nimport numpy as np\nimport gym\nfrom gym import spaces\nfrom .random import *\nfrom .opengl import *\nfrom .objmesh import *\nfrom .entity import *\nfrom .math import *\nfrom .params import *\n\n# Default wall height for room\nDEFAULT_WALL_HEIGHT=2.74\n\n# Texture size/density in texels/meter\nTEX_DENSITY = 512\n\ndef gen_texcs_wall(\n tex,\n min_x,\n min_y,\n width,\n height\n):\n \"\"\"\n Generate texture coordinates for a wall quad\n \"\"\"\n\n xc = (TEX_DENSITY / tex.width)\n yc = (TEX_DENSITY / tex.height)\n\n min_u = (min_x) * xc\n max_u = (min_x + width) * xc\n min_v = (min_y) * yc\n max_v = (min_y + height) * yc\n\n return np.array(\n [\n [min_u, min_v],\n [min_u, max_v],\n [max_u, max_v],\n [max_u, min_v],\n ],\n dtype=np.float32\n )\n\ndef gen_texcs_floor(\n tex,\n poss\n):\n \"\"\"\n Generate texture coordinates for the floor or ceiling\n This is done by mapping x,z positions directly to texture\n coordinates\n \"\"\"\n\n texc_mul = np.array(\n [\n TEX_DENSITY / tex.width,\n TEX_DENSITY / tex.height\n ],\n dtype=float\n )\n\n coords = np.stack([poss[:,0], poss[:,2]], axis=1) * texc_mul\n\n return coords\n\nclass Room:\n \"\"\"\n Represent an individual room and its contents\n \"\"\"\n\n def __init__(\n self,\n outline,\n wall_height=DEFAULT_WALL_HEIGHT,\n floor_tex='floor_tiles_bw',\n wall_tex='concrete',\n ceil_tex='concrete_tiles',\n no_ceiling=False\n ):\n # The outlien should have shape Nx2\n assert len(outline.shape) == 2\n assert outline.shape[1] == 2\n assert outline.shape[0] >= 3\n\n # Add a Y coordinate to the outline points\n outline = np.insert(outline, 1, 0, axis=1)\n\n # Number of outline vertices / walls\n self.num_walls = outline.shape[0]\n\n # List of 2D points forming the outline of the room\n # Shape is Nx3\n self.outline = outline\n\n # Compute the min and max x, z extents\n self.min_x = self.outline[:, 0].min()\n self.max_x = self.outline[:, 0].max()\n self.min_z = self.outline[:, 2].min()\n self.max_z = self.outline[:, 2].max()\n\n # Compute midpoint coordinates\n self.mid_x = (self.max_x + self.min_x) / 2\n self.mid_z = (self.max_z + self.min_z) / 2\n\n # Compute approximate surface area\n self.area = (self.max_x - self.min_x) * (self.max_z - self.min_z)\n\n # Compute room edge directions and normals\n # Compute edge vectors (p1 - p0)\n # For the first point, p0 is the last\n # For the last point, p0 is p_n-1\n next_pts = np.concatenate([self.outline[1:], np.expand_dims(self.outline[0], axis=0)], axis=0)\n self.edge_dirs = next_pts - self.outline\n self.edge_dirs = (self.edge_dirs.T / np.linalg.norm(self.edge_dirs, axis=1)).T\n self.edge_norms = -np.cross(self.edge_dirs, Y_VEC)\n self.edge_norms = (self.edge_norms.T / np.linalg.norm(self.edge_norms, axis=1)).T\n\n # Height of the room walls\n self.wall_height = wall_height\n\n # No ceiling flag\n self.no_ceiling = no_ceiling\n\n # Texture names\n self.wall_tex_name = wall_tex\n self.floor_tex_name = floor_tex\n self.ceil_tex_name = ceil_tex\n\n # Lists of portals, indexed by wall/edge index\n self.portals = [[] for i in range(self.num_walls)]\n\n # List of neighbor rooms\n # Same length as list of portals\n self.neighbors = []\n\n def add_portal(\n self,\n edge,\n start_pos=None,\n end_pos=None,\n min_x=None,\n max_x=None,\n min_z=None,\n max_z=None,\n min_y=0,\n max_y=None\n ):\n \"\"\"\n Create a new portal/opening in a wall of this room\n \"\"\"\n\n if max_y == None:\n max_y = self.wall_height\n\n assert edge <= self.num_walls\n assert max_y > min_y\n\n # Get the edge points, compute the direction vector\n e_p0 = self.outline[edge]\n e_p1 = self.outline[(edge+1) % self.num_walls]\n e_len = np.linalg.norm(e_p1 - e_p0)\n e_dir = (e_p1 - e_p0) / e_len\n x0, _, z0 = e_p0\n x1, _, z1 = e_p1\n dx, _, dz = e_dir\n\n # If the portal extents are specified by x coordinates\n if min_x != None:\n assert min_z == None and max_z == None\n assert start_pos == None and end_pos == None\n assert x0 != x1\n\n m0 = (min_x - x0) / dx\n m1 = (max_x - x0) / dx\n\n if m1 < m0:\n m0, m1 = m1, m0\n\n start_pos, end_pos = m0, m1\n\n # If the portal extents are specified by z coordinates\n elif min_z != None:\n assert min_x == None and max_x == None\n assert start_pos == None and end_pos == None\n assert z0 != z1\n\n m0 = (min_z - z0) / dz\n m1 = (max_z - z0) / dz\n\n if m1 < m0:\n m0, m1 = m1, m0\n\n start_pos, end_pos = m0, m1\n\n else:\n assert min_x == None and max_x == None\n assert min_z == None and max_z == None\n\n assert end_pos > start_pos\n assert start_pos >= 0, \"portal outside of wall extents\"\n assert end_pos <= e_len, \"portal outside of wall extents\"\n\n self.portals[edge].append({\n 'start_pos': start_pos,\n 'end_pos': end_pos,\n 'min_y': min_y,\n 'max_y': max_y\n })\n\n # Sort the portals by start position\n self.portals[edge].sort(key=lambda e: e['start_pos'])\n\n return start_pos, end_pos\n\n def point_inside(self, p):\n \"\"\"\n Test if a point is inside the room\n \"\"\"\n\n # Vector from edge start to test point\n ap = p - self.outline\n\n # Compute the dot products of normals to AP vectors\n dotNAP = np.sum(self.edge_norms * ap, axis=1)\n\n # The point is inside if all the dot products are greater than zero\n return np.all(np.greater(dotNAP, 0))\n\n def _gen_static_data(self, params, rng):\n \"\"\"\n Generate polygons and static data for this room\n Needed for rendering and collision detection\n Note: the wall polygons are quads, but the floor and\n ceiling can be arbitrary n-gons\n \"\"\"\n\n # Load the textures and do texture randomization\n self.wall_tex = Texture.get(self.wall_tex_name, rng)\n self.floor_tex = Texture.get(self.floor_tex_name, rng)\n self.ceil_tex = Texture.get(self.ceil_tex_name, rng)\n\n # Generate the floor vertices\n self.floor_verts = self.outline\n self.floor_texcs = gen_texcs_floor(\n self.floor_tex,\n self.floor_verts\n )\n\n # Generate the ceiling vertices\n # Flip the ceiling vertex order because of backface culling\n self.ceil_verts = np.flip(self.outline, axis=0) + self.wall_height * Y_VEC\n self.ceil_texcs = gen_texcs_floor(\n self.ceil_tex,\n self.ceil_verts\n )\n\n self.wall_verts = []\n self.wall_norms = []\n self.wall_texcs = []\n self.wall_segs = []\n\n def gen_seg_poly(\n edge_p0,\n side_vec,\n seg_start,\n seg_end,\n min_y,\n max_y\n ):\n if seg_end == seg_start:\n return\n\n if min_y == max_y:\n return\n\n s_p0 = edge_p0 + seg_start * side_vec\n s_p1 = edge_p0 + seg_end * side_vec\n\n # If this polygon starts at ground level, add a collidable segment\n if min_y == 0:\n self.wall_segs.append(np.array([s_p1, s_p0]))\n\n # Generate the vertices\n # Vertices are listed in counter-clockwise order\n self.wall_verts.append(s_p0 + min_y * Y_VEC)\n self.wall_verts.append(s_p0 + max_y * Y_VEC)\n self.wall_verts.append(s_p1 + max_y * Y_VEC)\n self.wall_verts.append(s_p1 + min_y * Y_VEC)\n\n # Compute the normal for the polygon\n normal = np.cross(s_p1 - s_p0, Y_VEC)\n normal = -normal / np.linalg.norm(normal)\n for i in range(4):\n self.wall_norms.append(normal)\n\n # Generate the texture coordinates\n texcs = gen_texcs_wall(\n self.wall_tex,\n seg_start,\n min_y,\n seg_end - seg_start,\n max_y - min_y\n )\n self.wall_texcs.append(texcs)\n\n # For each wall\n for wall_idx in range(self.num_walls):\n edge_p0 = self.outline[wall_idx, :]\n edge_p1 = self.outline[(wall_idx+1) % self.num_walls, :]\n wall_width = np.linalg.norm(edge_p1 - edge_p0)\n side_vec = (edge_p1 - edge_p0) / wall_width\n\n if len(self.portals[wall_idx]) > 0:\n seg_end = self.portals[wall_idx][0]['start_pos']\n else:\n seg_end = wall_width\n\n # Generate the first polygon (going up to the first portal)\n gen_seg_poly(\n edge_p0,\n side_vec,\n 0,\n seg_end,\n 0,\n self.wall_height\n )\n\n # For each portal in this wall\n for portal_idx, portal in enumerate(self.portals[wall_idx]):\n portal = self.portals[wall_idx][portal_idx]\n start_pos = portal['start_pos']\n end_pos = portal['end_pos']\n min_y = portal['min_y']\n max_y = portal['max_y']\n\n # Generate the bottom polygon\n gen_seg_poly(\n edge_p0,\n side_vec,\n start_pos,\n end_pos,\n 0,\n min_y\n )\n\n # Generate the top polygon\n gen_seg_poly(\n edge_p0,\n side_vec,\n start_pos,\n end_pos,\n max_y,\n self.wall_height\n )\n\n if portal_idx < len(self.portals[wall_idx]) - 1:\n next_portal = self.portals[wall_idx][portal_idx+1]\n next_portal_start = next_portal['start_pos']\n else:\n next_portal_start = wall_width\n\n # Generate the polygon going up to the next portal\n gen_seg_poly(\n edge_p0,\n side_vec,\n end_pos,\n next_portal_start,\n 0,\n self.wall_height\n )\n\n self.wall_verts = np.array(self.wall_verts)\n self.wall_norms = np.array(self.wall_norms)\n\n if len(self.wall_segs) > 0:\n self.wall_segs = np.array(self.wall_segs)\n else:\n self.wall_segs = np.array([]).reshape(0, 2, 3)\n\n if len(self.wall_texcs) > 0:\n self.wall_texcs = np.concatenate(self.wall_texcs)\n else:\n self.wall_texcs = np.array([]).reshape(0, 2)\n\n def _render(self):\n \"\"\"\n Render the static elements of the room\n \"\"\"\n\n glColor3f(1, 1, 1)\n\n # Draw the floor\n self.floor_tex.bind()\n glBegin(GL_POLYGON)\n glNormal3f(0, 1, 0)\n for i in range(self.floor_verts.shape[0]):\n glTexCoord2f(*self.floor_texcs[i, :])\n glVertex3f(*self.floor_verts[i, :])\n glEnd()\n\n # Draw the ceiling\n if not self.no_ceiling:\n self.ceil_tex.bind()\n glBegin(GL_POLYGON)\n glNormal3f(0, -1, 0)\n for i in range(self.ceil_verts.shape[0]):\n glTexCoord2f(*self.ceil_texcs[i, :])\n glVertex3f(*self.ceil_verts[i, :])\n glEnd()\n\n # Draw the walls\n self.wall_tex.bind()\n glBegin(GL_QUADS)\n for i in range(self.wall_verts.shape[0]):\n glNormal3f(*self.wall_norms[i, :])\n glTexCoord2f(*self.wall_texcs[i, :])\n glVertex3f(*self.wall_verts[i, :])\n glEnd()\n\nclass MiniWorldEnv(gym.Env):\n \"\"\"\n Base class for MiniWorld environments. Implements the procedural\n world generation and simulation logic.\n \"\"\"\n\n metadata = {\n 'render.modes': ['human', 'rgb_array'],\n 'video.frames_per_second' : 30\n }\n\n # Enumeration of possible actions\n class Actions(IntEnum):\n # Turn left or right by a small amount\n turn_left = 0\n turn_right = 1\n\n # Move forward or back by a small amount\n move_forward = 2\n move_back = 3\n\n # Pick up or drop an object being carried\n pickup = 4\n drop = 5\n\n # Toggle/activate an object\n toggle = 6\n\n # Done completing task\n done = 7\n\n def __init__(\n self,\n max_episode_steps=1500,\n obs_width=80,\n obs_height=60,\n window_width=800,\n window_height=600,\n params=DEFAULT_PARAMS,\n domain_rand=False\n ):\n # Action enumeration for this environment\n self.actions = MiniWorldEnv.Actions\n\n # Actions are discrete integer values\n self.action_space = spaces.Discrete(len(self.actions))\n\n # Observations are RGB images with pixels in [0, 255]\n self.observation_space = spaces.Box(\n low=0,\n high=255,\n shape=(obs_height, obs_width, 3),\n dtype=np.uint8\n )\n\n self.reward_range = (-math.inf, math.inf)\n\n # Maximum number of steps per episode\n self.max_episode_steps = max_episode_steps\n\n # Simulation parameters, used for domain randomization\n self.params = params\n\n # Domain randomization enable/disable flag\n self.domain_rand = domain_rand\n\n # Window for displaying the environment to humans\n self.window = None\n\n # Invisible window to render into (shadow OpenGL context)\n self.shadow_window = pyglet.window.Window(width=1, height=1, visible=False)\n\n # Enable depth testing and backface culling\n glEnable(GL_DEPTH_TEST)\n glEnable(GL_CULL_FACE)\n\n # Frame buffer used to render observations\n self.obs_fb = FrameBuffer(obs_width, obs_height, 8)\n\n # Frame buffer used for human visualization\n self.vis_fb = FrameBuffer(window_width, window_height, 16)\n\n # Compute the observation display size\n self.obs_disp_width = 256\n self.obs_disp_height = obs_height * (self.obs_disp_width / obs_width)\n\n # For displaying text\n self.text_label = pyglet.text.Label(\n font_name=\"Arial\",\n font_size=14,\n multiline=True,\n width=400,\n x = window_width + 5,\n y = window_height - (self.obs_disp_height + 19)\n )\n\n # Initialize the state\n self.seed()\n self.reset()\n\n def close(self):\n pass\n\n def seed(self, seed=None):\n self.rand = RandGen(seed)\n return [seed]\n\n def reset(self):\n \"\"\"\n Reset the simulation at the start of a new episode\n This also randomizes many environment parameters (domain randomization)\n \"\"\"\n\n # Step count since episode start\n self.step_count = 0\n\n # Create the agent\n self.agent = Agent()\n\n # List of entities contained\n self.entities = []\n\n # List of rooms in the world\n self.rooms = []\n\n # Wall segments for collision detection\n # Shape is (N, 2, 3)\n self.wall_segs = []\n\n # Generate the world\n self._gen_world()\n\n # Check if domain randomization is enabled or not\n rand = self.rand if self.domain_rand else None\n\n # Randomize elements of the world (domain randomization)\n self.params.sample_many(rand, self, [\n 'sky_color',\n 'light_pos',\n 'light_color',\n 'light_ambient'\n ])\n\n # Get the max forward step distance\n self.max_forward_step = self.params.get_max('forward_step')\n\n # Randomize parameters of the entities\n for ent in self.entities:\n ent.randomize(self.params, rand)\n\n # Compute the min and max x, z extents of the whole floorplan\n self.min_x = min([r.min_x for r in self.rooms])\n self.max_x = max([r.max_x for r in self.rooms])\n self.min_z = min([r.min_z for r in self.rooms])\n self.max_z = max([r.max_z for r in self.rooms])\n\n # Generate static data\n if len(self.wall_segs) == 0:\n self._gen_static_data()\n\n # Pre-compile static parts of the environment into a display list\n self._render_static()\n\n # Generate the first camera image\n obs = self.render_obs()\n\n # Return first observation\n return obs\n\n def _get_carry_pos(self, agent_pos, ent):\n \"\"\"\n Compute the position at which to place an object being carried\n \"\"\"\n\n dist = self.agent.radius + ent.radius + self.max_forward_step\n pos = agent_pos + self.agent.dir_vec * 1.05 * dist\n\n # Adjust the Y-position so the object is visible while being carried\n y_pos = max(self.agent.cam_height - ent.height - 0.3, 0)\n pos = pos + Y_VEC * y_pos\n\n return pos\n\n def move_agent(self, fwd_dist, fwd_drift):\n \"\"\"\n Move the agent forward\n \"\"\"\n\n next_pos = (\n self.agent.pos +\n self.agent.dir_vec * fwd_dist +\n self.agent.right_vec * fwd_drift\n )\n\n if self.intersect(self.agent, next_pos, self.agent.radius):\n return False\n\n carrying = self.agent.carrying\n if carrying:\n next_carrying_pos = self._get_carry_pos(next_pos, carrying)\n\n if self.intersect(carrying, next_carrying_pos, carrying.radius):\n return False\n\n carrying.pos = next_carrying_pos\n\n self.agent.pos = next_pos\n\n return True\n\n def turn_agent(self, turn_angle):\n \"\"\"\n Turn the agent left or right\n \"\"\"\n\n turn_angle *= (math.pi / 180)\n orig_dir = self.agent.dir\n\n self.agent.dir += turn_angle\n\n carrying = self.agent.carrying\n if carrying:\n pos = self._get_carry_pos(self.agent.pos, carrying)\n\n if self.intersect(carrying, pos, carrying.radius):\n self.agent.dir = orig_dir\n return False\n\n carrying.pos = pos\n carrying.dir = self.agent.dir\n\n return True\n\n def step(self, action):\n \"\"\"\n Perform one action and update the simulation\n \"\"\"\n\n self.step_count += 1\n\n rand = self.rand if self.domain_rand else None\n fwd_step = self.params.sample(rand, 'forward_step')\n fwd_drift = self.params.sample(rand, 'forward_drift')\n turn_step = self.params.sample(rand, 'turn_step')\n\n if action == self.actions.move_forward:\n self.move_agent(fwd_step, fwd_drift)\n\n elif action == self.actions.move_back:\n self.move_agent(-fwd_step, fwd_drift)\n\n elif action == self.actions.turn_left:\n self.turn_agent(turn_step)\n\n elif action == self.actions.turn_right:\n self.turn_agent(-turn_step)\n\n # Pick up an object\n elif action == self.actions.pickup:\n # Position at which we will test for an intersection\n test_pos = self.agent.pos + self.agent.dir_vec * 1.5 * self.agent.radius\n ent = self.intersect(self.agent, test_pos, 1.2 * self.agent.radius)\n if not self.agent.carrying:\n if isinstance(ent, Entity):\n if not ent.is_static:\n self.agent.carrying = ent\n\n # Drop an object being carried\n elif action == self.actions.drop:\n if self.agent.carrying:\n self.agent.carrying.pos[1] = 0\n self.agent.carrying = None\n\n # If we are carrying an object, update its position as we move\n if self.agent.carrying:\n ent_pos = self._get_carry_pos(self.agent.pos, self.agent.carrying)\n self.agent.carrying.pos = ent_pos\n self.agent.carrying.dir = self.agent.dir\n\n # Generate the current camera image\n obs = self.render_obs()\n\n # If the maximum time step count is reached\n if self.step_count >= self.max_episode_steps:\n done = True\n reward = 0\n return obs, reward, done, {}\n\n reward = 0\n done = False\n\n return obs, reward, done, {}\n\n def add_rect_room(\n self,\n min_x,\n max_x,\n min_z,\n max_z,\n **kwargs\n ):\n \"\"\"\n Create a rectangular room\n \"\"\"\n\n # 2D outline coordinates of the room,\n # listed in counter-clockwise order when viewed from the top\n outline = np.array([\n # East wall\n [max_x, max_z],\n # North wall\n [max_x, min_z],\n # West wall\n [min_x, min_z],\n # South wall\n [min_x, max_z],\n ])\n\n return self.add_room(outline=outline, **kwargs)\n\n def add_room(self, **kwargs):\n \"\"\"\n Create a new room\n \"\"\"\n\n assert len(self.wall_segs) == 0, \"cannot add rooms after static data is generated\"\n\n room = Room(**kwargs)\n self.rooms.append(room)\n\n return room\n\n def connect_rooms(\n self,\n room_a,\n room_b,\n min_x=None,\n max_x=None,\n min_z=None,\n max_z=None,\n max_y=None\n ):\n \"\"\"\n Connect two rooms along facing edges\n \"\"\"\n\n def find_facing_edges():\n for idx_a in range(room_a.num_walls):\n norm_a = room_a.edge_norms[idx_a]\n\n for idx_b in range(room_b.num_walls):\n norm_b = room_b.edge_norms[idx_b]\n\n # Reject edges that are not facing each other\n if np.dot(norm_a, norm_b) > -0.9:\n continue\n\n dir = room_b.outline[idx_b] - room_a.outline[idx_a]\n\n # Reject edges that are not touching\n if np.dot(norm_a, dir) > 0.05:\n continue\n\n return idx_a, idx_b\n\n return None, None\n\n idx_a, idx_b = find_facing_edges()\n assert idx_a != None, \"matching edges not found in connect_rooms\"\n\n start_a, end_a = room_a.add_portal(\n edge=idx_a,\n min_x=min_x,\n max_x=max_x,\n min_z=min_z,\n max_z=max_z,\n max_y=max_y\n )\n\n start_b, end_b = room_b.add_portal(\n edge=idx_b,\n min_x=min_x,\n max_x=max_x,\n min_z=min_z,\n max_z=max_z,\n max_y=max_y\n )\n\n a = room_a.outline[idx_a] + room_a.edge_dirs[idx_a] * start_a\n b = room_a.outline[idx_a] + room_a.edge_dirs[idx_a] * end_a\n c = room_b.outline[idx_b] + room_b.edge_dirs[idx_b] * start_b\n d = room_b.outline[idx_b] + room_b.edge_dirs[idx_b] * end_b\n\n # If the portals are directly connected, stop\n if np.linalg.norm(a - d) < 0.001:\n return\n\n len_a = np.linalg.norm(b - a)\n len_b = np.linalg.norm(d - c)\n\n # Room outline points must be specified in counter-clockwise order\n outline = np.stack([c, b, a, d])\n outline = np.stack([outline[:, 0], outline[:, 2]], axis=1)\n\n max_y = max_y if max_y != None else room_a.wall_height\n\n room = Room(\n outline,\n wall_height=max_y,\n wall_tex=room_a.wall_tex_name,\n floor_tex=room_a.floor_tex_name,\n ceil_tex=room_a.ceil_tex_name,\n no_ceiling=room_a.no_ceiling,\n )\n\n self.rooms.append(room)\n\n room.add_portal(1, start_pos=0, end_pos=len_a)\n room.add_portal(3, start_pos=0, end_pos=len_b)\n\n def place_entity(\n self,\n ent,\n room=None,\n pos=None,\n dir=None,\n min_x=None,\n max_x=None,\n min_z=None,\n max_z=None\n ):\n \"\"\"\n Place an entity/object in the world.\n Find a position that doesn't intersect with any other object.\n \"\"\"\n\n assert len(self.rooms) > 0, \"create rooms before calling place_entity\"\n assert ent.radius != None, \"entity must have physical size defined\"\n\n # Generate collision detection data\n if len(self.wall_segs) == 0:\n self._gen_static_data()\n\n # If an exact position if specified\n if pos is not None:\n ent.dir = dir if dir != None else self.rand.float(-math.pi, math.pi)\n ent.pos = pos\n self.entities.append(ent)\n return ent\n\n # Keep retrying until we find a suitable position\n while True:\n # Pick a room, sample rooms proportionally to floor surface area\n r = room if room else self.rand.choice(self.rooms, probs=self.room_probs)\n\n # Choose a random point within the square bounding box of the room\n lx = r.min_x if min_x == None else min_x\n hx = r.max_x if max_x == None else max_x\n lz = r.min_z if min_z == None else min_z\n hz = r.max_z if max_z == None else max_z\n pos = self.rand.float(\n low =[lx + ent.radius, 0, lz + ent.radius],\n high=[hx - ent.radius, 0, hz - ent.radius]\n )\n\n # Make sure the position is within the room's outline\n if not r.point_inside(pos):\n continue\n\n # Make sure the position doesn't intersect with any walls\n if self.intersect(ent, pos, ent.radius):\n continue\n\n # Pick a direction\n d = dir if dir != None else self.rand.float(-math.pi, math.pi)\n\n ent.pos = pos\n ent.dir = d\n break\n\n self.entities.append(ent)\n\n return ent\n\n def place_agent(\n self,\n room=None,\n dir=None,\n min_x=None,\n max_x=None,\n min_z=None,\n max_z=None\n ):\n \"\"\"\n Place the agent in the environment at a random position\n and orientation\n \"\"\"\n\n return self.place_entity(\n self.agent,\n room=room,\n dir=dir,\n min_x=min_x,\n max_x=max_x,\n min_z=min_z,\n max_z=max_z\n )\n\n def intersect(self, ent, pos, radius):\n \"\"\"\n Check if an entity intersects with the world\n \"\"\"\n\n # Ignore the Y position\n px, _, pz = pos\n pos = np.array([px, 0, pz])\n\n # Check for intersection with walls\n if intersect_circle_segs(pos, radius, self.wall_segs):\n return True\n\n # Check for entity intersection\n for ent2 in self.entities:\n # Entities can't intersect with themselves\n if ent2 is ent:\n continue\n\n px, _, pz = ent2.pos\n pos2 = np.array([px, 0, pz])\n\n d = np.linalg.norm(pos2 - pos)\n if d < radius + ent2.radius:\n return ent2\n\n return None\n\n def near(self, ent0, ent1=None):\n \"\"\"\n Test if the two entities are near each other.\n Used for \"go to\" or \"put next\" type tasks\n \"\"\"\n\n if ent1 == None:\n ent1 = self.agent\n\n dist = np.linalg.norm(ent0.pos - ent1.pos)\n return dist < ent0.radius + ent1.radius + 1.1 * self.max_forward_step\n\n def _load_tex(self, tex_name):\n \"\"\"\n Load a texture, with or without domain randomization\n \"\"\"\n\n rand = self.rand if self.params.sample(self.rand, 'tex_rand') else None\n return Texture.get(tex_name, rand)\n\n def _gen_static_data(self):\n \"\"\"\n Generate static data needed for rendering and collision detection\n \"\"\"\n\n # Generate the static data for each room\n for room in self.rooms:\n room._gen_static_data(\n self.params,\n self.rand if self.domain_rand else None\n )\n\n # Concatenate the wall segments\n self.wall_segs = np.concatenate([r.wall_segs for r in self.rooms])\n\n # Room selection probabilities\n self.room_probs = np.array([r.area for r in self.rooms], dtype=float)\n self.room_probs /= np.sum(self.room_probs)\n\n def _gen_world(self):\n \"\"\"\n Generate the world. Derived classes must implement this method.\n \"\"\"\n\n raise NotImplementedError\n\n def _reward(self):\n \"\"\"\n Default sparse reward computation\n \"\"\"\n\n return 1.0 - 0.2 * (self.step_count / self.max_episode_steps)\n\n def _render_static(self):\n \"\"\"\n Render the static elements of the scene into a display list.\n Called once at the beginning of each episode.\n \"\"\"\n\n # TODO: manage this automatically\n # glIsList\n glDeleteLists(1, 1);\n glNewList(1, GL_COMPILE);\n\n # Light position\n glLightfv(GL_LIGHT0, GL_POSITION, (GLfloat*4)(*self.light_pos + [1]))\n\n # Background/minimum light level\n glLightfv(GL_LIGHT0, GL_AMBIENT, (GLfloat*4)(*self.light_ambient))\n\n # Diffuse light color\n glLightfv(GL_LIGHT0, GL_DIFFUSE, (GLfloat*4)(*self.light_color))\n\n #glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 180)\n #glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0)\n #glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0)\n #glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0)\n #glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0)\n\n glEnable(GL_LIGHTING)\n glEnable(GL_LIGHT0)\n\n glShadeModel(GL_SMOOTH)\n glEnable(GL_COLOR_MATERIAL)\n glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)\n\n # Render the rooms\n glEnable(GL_TEXTURE_2D)\n for room in self.rooms:\n room._render()\n\n # Render the static entities\n for ent in self.entities:\n if ent.is_static:\n ent.render()\n\n glEndList()\n\n def _render_world(\n self,\n frame_buffer,\n render_agent\n ):\n \"\"\"\n Render the world from a given camera position into a frame buffer,\n and produce a numpy image array as output.\n \"\"\"\n\n # Call the display list for the static parts of the environment\n glCallList(1)\n\n # TODO: keep the non-static entities in a different list for efficiency?\n # Render the non-static entities\n for ent in self.entities:\n if not ent.is_static and ent is not self.agent:\n ent.render()\n #ent.draw_bound()\n\n if render_agent:\n self.agent.render()\n\n # Resolve the rendered image into a numpy array\n img = frame_buffer.resolve()\n\n return img\n\n def render_top_view(self, frame_buffer=None):\n \"\"\"\n Render a top view of the whole map (from above)\n \"\"\"\n\n if frame_buffer == None:\n frame_buffer = self.obs_fb\n\n # Switch to the default OpenGL context\n # This is necessary on Linux Nvidia drivers\n self.shadow_window.switch_to()\n\n # Bind the frame buffer before rendering into it\n frame_buffer.bind()\n\n # Clear the color and depth buffers\n glClearColor(*self.sky_color, 1.0)\n glClearDepth(1.0)\n glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)\n\n # Scene extents to render\n min_x = self.min_x - 1\n max_x = self.max_x + 1\n min_z = self.min_z - 1\n max_z = self.max_z + 1\n\n width = max_x - min_x\n height = max_z - min_z\n aspect = width / height\n fb_aspect = frame_buffer.width / frame_buffer.height\n\n # Adjust the aspect extents to match the frame buffer aspect\n if aspect > fb_aspect:\n # Want to add to denom, add to height\n new_h = width / fb_aspect\n h_diff = new_h - height\n min_z -= h_diff / 2\n max_z += h_diff / 2\n elif aspect < fb_aspect:\n # Want to add to num, add to width\n new_w = height * fb_aspect\n w_diff = new_w - width\n min_x -= w_diff / 2\n max_x += w_diff / 2\n\n # Set the projection matrix\n glMatrixMode(GL_PROJECTION)\n glLoadIdentity()\n glOrtho(\n min_x,\n max_x,\n -max_z,\n -min_z,\n -100, 100.0\n )\n\n # Setup the camera\n # Y maps to +Z, Z maps to +Y\n glMatrixMode(GL_MODELVIEW)\n glLoadIdentity()\n m = [\n 1, 0, 0, 0,\n 0, 0, 1, 0,\n 0, -1, 0, 0,\n 0, 0, 0, 1,\n ]\n glLoadMatrixf((GLfloat * len(m))(*m))\n\n return self._render_world(\n frame_buffer,\n render_agent=True\n )\n\n def render_obs(self, frame_buffer=None):\n \"\"\"\n Render an observation from the point of view of the agent\n \"\"\"\n\n if frame_buffer == None:\n frame_buffer = self.obs_fb\n\n # Switch to the default OpenGL context\n # This is necessary on Linux Nvidia drivers\n self.shadow_window.switch_to()\n\n # Bind the frame buffer before rendering into it\n frame_buffer.bind()\n\n # Clear the color and depth buffers\n glClearColor(*self.sky_color, 1.0)\n glClearDepth(1.0)\n glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)\n\n # Set the projection matrix\n glMatrixMode(GL_PROJECTION)\n glLoadIdentity()\n gluPerspective(\n self.agent.cam_fov_y,\n frame_buffer.width / float(frame_buffer.height),\n 0.04,\n 100.0\n )\n\n # Setup the camera\n glMatrixMode(GL_MODELVIEW)\n glLoadIdentity()\n gluLookAt(\n # Eye position\n *self.agent.cam_pos,\n # Target\n *(self.agent.cam_pos + self.agent.cam_dir),\n # Up vector\n 0, 1.0, 0.0\n )\n\n return self._render_world(\n frame_buffer,\n render_agent=False\n )\n\n def render_depth(self, frame_buffer=None):\n \"\"\"\n Produce a depth map\n Values are floating-point, map shape is (H,W,1)\n Distances are in meters from the observer\n \"\"\"\n\n if frame_buffer == None:\n frame_buffer = self.obs_fb\n\n # Render the world\n self.render_obs(frame_buffer)\n\n return frame_buffer.get_depth_map(0.04, 100.0)\n\n def get_visible_ents(self):\n \"\"\"\n Get a list of visible entities.\n Uses OpenGL occlusion queries to approximate visibility.\n :return: set of objects visible to the agent\n \"\"\"\n\n # Allocate the occlusion query ids\n num_ents = len(self.entities)\n query_ids = (GLuint * num_ents)()\n glGenQueries(num_ents, query_ids)\n\n # Switch to the default OpenGL context\n # This is necessary on Linux Nvidia drivers\n self.shadow_window.switch_to()\n\n # Use the small observation frame buffer\n frame_buffer = self.obs_fb\n\n # Bind the frame buffer before rendering into it\n frame_buffer.bind()\n\n # Clear the color and depth buffers\n glClearColor(*self.sky_color, 1.0)\n glClearDepth(1.0)\n glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)\n\n # Set the projection matrix\n glMatrixMode(GL_PROJECTION)\n glLoadIdentity()\n gluPerspective(\n self.agent.cam_fov_y,\n frame_buffer.width / float(frame_buffer.height),\n 0.04,\n 100.0\n )\n\n # Setup the cameravisible objects\n glMatrixMode(GL_MODELVIEW)\n glLoadIdentity()\n gluLookAt(\n # Eye position\n *self.agent.cam_pos,\n # Target\n *(self.agent.cam_pos + self.agent.cam_dir),\n # Up vector\n 0, 1.0, 0.0\n )\n\n # Render the rooms, without texturing\n glDisable(GL_TEXTURE_2D)\n for room in self.rooms:\n room._render()\n\n # For each entity\n for ent_idx, ent in enumerate(self.entities):\n if ent is self.agent:\n continue\n\n glBeginQuery(GL_ANY_SAMPLES_PASSED, query_ids[ent_idx])\n pos = ent.pos\n\n #glColor3f(1, 0, 0)\n drawBox(\n x_min=pos[0] - 0.1,\n x_max=pos[0] + 0.1,\n y_min=pos[1],\n y_max=pos[1] + 0.2,\n z_min=pos[2] - 0.1,\n z_max=pos[2] + 0.1\n )\n\n glEndQuery(GL_ANY_SAMPLES_PASSED)\n\n vis_objs = set()\n\n # Get query results\n for ent_idx, ent in enumerate(self.entities):\n if ent is self.agent:\n continue\n\n visible = (GLuint*1)(1)\n glGetQueryObjectuiv(query_ids[ent_idx], GL_QUERY_RESULT, visible);\n\n if visible[0] != 0:\n vis_objs.add(ent)\n\n # Free the occlusion query ids\n glDeleteQueries(1, query_ids)\n\n #img = frame_buffer.resolve()\n #return img\n\n return vis_objs\n\n def render(self, mode='human', close=False, view='agent'):\n \"\"\"\n Render the environment for human viewing\n \"\"\"\n\n if close:\n if self.window:\n self.window.close()\n return\n\n # Render the human-view image\n assert view in ['agent', 'top']\n if view == 'agent':\n img = self.render_obs(self.vis_fb)\n else:\n img = self.render_top_view(self.vis_fb)\n img_width = img.shape[1]\n img_height = img.shape[0]\n\n if mode == 'rgb_array':\n return img\n\n # Render the agent's view\n obs = self.render_obs()\n obs_width = obs.shape[1]\n obs_height = obs.shape[0]\n\n window_width = img_width + self.obs_disp_width\n window_height = img_height\n\n if self.window is None:\n config = pyglet.gl.Config(double_buffer=True)\n self.window = pyglet.window.Window(\n width=window_width,\n height=window_height,\n resizable=False,\n config=config\n )\n\n self.window.clear()\n self.window.switch_to()\n\n # Bind the default frame buffer\n glBindFramebuffer(GL_FRAMEBUFFER, 0);\n\n # Clear the color and depth buffers\n glClearColor(0, 0, 0, 1.0)\n glClearDepth(1.0)\n glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\n\n # Setup orghogonal projection\n glMatrixMode(GL_PROJECTION)\n glLoadIdentity()\n glMatrixMode(GL_MODELVIEW)\n glLoadIdentity()\n glOrtho(0, window_width, 0, window_height, 0, 10)\n\n # Draw the human render to the rendering window\n img_flip = np.ascontiguousarray(np.flip(img, axis=0))\n img_data = pyglet.image.ImageData(\n img_width,\n img_height,\n 'RGB',\n img_flip.ctypes.data_as(POINTER(GLubyte)),\n pitch=img_width * 3,\n )\n img_data.blit(\n 0,\n 0,\n 0,\n width=img_width,\n height=img_height\n )\n\n # Draw the observation\n obs = np.ascontiguousarray(np.flip(obs, axis=0))\n obs_data = pyglet.image.ImageData(\n obs_width,\n obs_height,\n 'RGB',\n obs.ctypes.data_as(POINTER(GLubyte)),\n pitch=obs_width * 3,\n )\n obs_data.blit(\n img_width,\n img_height - self.obs_disp_height,\n 0,\n width=self.obs_disp_width,\n height=self.obs_disp_height\n )\n\n # Draw the text label in the window\n self.text_label.text = \"pos: (%.2f, %.2f, %.2f)\\nangle: %d\\nsteps: %d\" % (\n *self.agent.pos,\n int(self.agent.dir * 180 / math.pi) % 360,\n self.step_count\n )\n self.text_label.draw()\n\n # Force execution of queued commands\n glFlush()\n\n # If we are not running the Pyglet event loop,\n # we have to manually flip the buffers and dispatch events\n if mode == 'human':\n self.window.flip()\n self.window.dispatch_events()\n\n return img\n",
"import math\nimport numpy as np\nfrom .math import *\nfrom .opengl import *\nfrom .objmesh import ObjMesh\n\n# Map of color names to RGB values\nCOLORS = {\n 'red' : np.array([1.0, 0.0, 0.0]),\n 'green' : np.array([0.0, 1.0, 0.0]),\n 'blue' : np.array([0.0, 0.0, 1.0]),\n 'purple': np.array([0.44, 0.15, 0.76]),\n 'yellow': np.array([1.00, 1.00, 0.00]),\n 'grey' : np.array([0.39, 0.39, 0.39]),\n 'snow'\t: np.array([255., 250., 250.])/255.,\n 'grey'\t: np.array([190., 190., 190.])/255.,\n}\n\n# List of color names, sorted alphabetically\nCOLOR_NAMES = sorted(list(COLORS.keys()))\n\nclass Entity:\n def __init__(self):\n # World position\n # Note: for most entities, the position is at floor level\n self.pos = None\n\n # Direction/orientation angle in radians\n self.dir = None\n\n # Radius for bounding circle/cylinder\n self.radius = 0\n\n # Height of bounding cylinder\n self.height = 0\n\n def randomize(self, params, rng):\n \"\"\"\n Set the domain randomization parameters\n \"\"\"\n pass\n\n def render(self):\n \"\"\"\n Draw the object\n \"\"\"\n raise NotImplementedError\n\n def step(self, delta_time):\n \"\"\"\n Update the state of the object\n \"\"\"\n pass\n\n def draw_bound(self):\n \"\"\"\n Draw the bounding circle\n Used for debugging purposes\n \"\"\"\n\n x, _, z = self.pos\n\n glColor3f(1, 0, 0)\n glBegin(GL_LINES)\n\n for i in range(60):\n a = i * 2 * math.pi / 60\n cx = x + self.radius * math.cos(a)\n cz = z + self.radius * math.sin(a)\n glVertex3f(cx, 0.01, cz)\n\n glEnd()\n\n @property\n def dir_vec(self):\n \"\"\"\n Vector pointing in the direction of forward movement\n \"\"\"\n\n x = math.cos(self.dir)\n z = -math.sin(self.dir)\n return np.array([x, 0, z])\n\n @property\n def right_vec(self):\n \"\"\"\n Vector pointing to the right of the agent\n \"\"\"\n\n x = math.sin(self.dir)\n z = math.cos(self.dir)\n return np.array([x, 0, z])\n\n @property\n def is_static(self):\n \"\"\"\n True for objects that cannot move or animate\n (can be rendered statically)\n \"\"\"\n return False\n\nclass MeshEnt(Entity):\n \"\"\"\n Entity whose appearance is defined by a mesh file\n\n height -- scale the model to this height\n static -- flag indicating this object cannot move\n \"\"\"\n\n def __init__(\n self,\n mesh_name,\n height,\n static=True\n ):\n super().__init__()\n\n self.static = static\n\n # Load the mesh\n self.mesh = ObjMesh.get(mesh_name)\n\n # Get the mesh extents\n sx, sy, sz = self.mesh.max_coords\n\n # Compute the mesh scaling factor\n self.scale = height / sy\n\n # Compute the radius and height\n self.radius = math.sqrt(sx*sx + sz*sz) * self.scale\n self.height = height\n\n def render(self):\n \"\"\"\n Draw the object\n \"\"\"\n\n glPushMatrix()\n glTranslatef(*self.pos)\n glScalef(self.scale, self.scale, self.scale)\n glRotatef(self.dir * 180 / math.pi, 0, 1, 0)\n glColor3f(1, 1, 1)\n self.mesh.render()\n glPopMatrix()\n\n @property\n def is_static(self):\n return self.static\n\nclass ImageFrame(Entity):\n \"\"\"\n Frame to display an image on a wall\n Note: the position is in the middle of the frame, on the wall\n \"\"\"\n\n def __init__(self, pos, dir, tex_name, width, depth=0.05):\n super().__init__()\n\n self.pos = pos\n self.dir = dir\n\n # Load the image to be displayed\n self.tex = Texture.get(tex_name)\n\n self.width = width\n self.depth = depth\n self.height = (float(self.tex.height) / self.tex.width) * self.width\n\n @property\n def is_static(self):\n return True\n\n def render(self):\n \"\"\"\n Draw the object\n \"\"\"\n\n x, y, z = self.pos\n\n # sx is depth\n # Frame points towards +sx\n sx = self.depth\n hz = self.width / 2\n hy = self.height / 2\n\n glPushMatrix()\n glTranslatef(*self.pos)\n glRotatef(self.dir * (180/math.pi), 0, 1, 0)\n\n # Bind texture for front\n glColor3f(1, 1, 1)\n glEnable(GL_TEXTURE_2D)\n self.tex.bind()\n\n # Front face, showing image\n glBegin(GL_QUADS)\n glNormal3f(1, 0, 0)\n glTexCoord2f(1, 1)\n glVertex3f(sx, +hy, -hz)\n glTexCoord2f(0, 1)\n glVertex3f(sx, +hy, +hz)\n glTexCoord2f(0, 0)\n glVertex3f(sx, -hy, +hz)\n glTexCoord2f(1, 0)\n glVertex3f(sx, -hy, -hz)\n glEnd()\n\n # Black frame/border\n glDisable(GL_TEXTURE_2D)\n glColor3f(0, 0, 0)\n\n glBegin(GL_QUADS)\n\n # Left\n glNormal3f(0, 0, -1)\n glVertex3f(0 , +hy, -hz)\n glVertex3f(+sx, +hy, -hz)\n glVertex3f(+sx, -hy, -hz)\n glVertex3f(0 , -hy, -hz)\n\n # Right\n glNormal3f(0, 0, 1)\n glVertex3f(+sx, +hy, +hz)\n glVertex3f(0 , +hy, +hz)\n glVertex3f(0 , -hy, +hz)\n glVertex3f(+sx, -hy, +hz)\n\n # Top\n glNormal3f(0, 1, 0)\n glVertex3f(+sx, +hy, +hz)\n glVertex3f(+sx, +hy, -hz)\n glVertex3f(0 , +hy, -hz)\n glVertex3f(0 , +hy, +hz)\n\n # Bottom\n glNormal3f(0, -1, 0)\n glVertex3f(+sx, -hy, -hz)\n glVertex3f(+sx, -hy, +hz)\n glVertex3f(0 , -hy, +hz)\n glVertex3f(0 , -hy, -hz)\n\n glEnd()\n\n glPopMatrix()\n\nclass TextFrame(Entity):\n \"\"\"\n Frame to display text or numbers on a wall\n Note: the position is in the middle of the frame, on the wall\n \"\"\"\n\n def __init__(self, pos, dir, str, height=0.15, depth=0.05):\n super().__init__()\n\n self.pos = pos\n self.dir = dir\n\n self.str = str\n\n self.depth = depth\n self.height = height\n self.width = len(str) * height\n\n @property\n def is_static(self):\n return True\n\n def randomize(self, params, rng):\n self.texs = []\n for ch in self.str:\n try:\n if ch == ' ':\n self.texs.append(None)\n else:\n tex_name = f'chars/ch_0x{ord(ch)}'\n self.texs.append(Texture.get(tex_name, rng))\n except:\n raise 'only alphanumerical characters supported in TextFrame'\n\n def render(self):\n \"\"\"\n Draw the object\n \"\"\"\n\n x, y, z = self.pos\n\n # sx is depth\n # Frame points towards +sx\n sx = 0.05\n hz = self.width / 2\n hy = self.height / 2\n\n glPushMatrix()\n glTranslatef(*self.pos)\n glRotatef(self.dir * (180/math.pi), 0, 1, 0)\n\n # Bind texture for front\n glColor3f(1, 1, 1)\n\n # For each character\n for idx, ch in enumerate(self.str):\n tex = self.texs[idx]\n if tex:\n glEnable(GL_TEXTURE_2D)\n self.texs[idx].bind()\n else:\n glDisable(GL_TEXTURE_2D)\n\n char_width = self.height\n z_0 = hz - char_width * (idx+1)\n z_1 = z_0 + char_width\n\n # Front face, showing image\n glBegin(GL_QUADS)\n glNormal3f(1, 0, 0)\n glTexCoord2f(1, 1)\n glVertex3f(sx, +hy, z_0)\n glTexCoord2f(0, 1)\n glVertex3f(sx, +hy, z_1)\n glTexCoord2f(0, 0)\n glVertex3f(sx, -hy, z_1)\n glTexCoord2f(1, 0)\n glVertex3f(sx, -hy, z_0)\n glEnd()\n\n # Black frame/border\n glDisable(GL_TEXTURE_2D)\n glColor3f(0, 0, 0)\n\n glBegin(GL_QUADS)\n\n # Left\n glNormal3f(0, 0, -1)\n glVertex3f(0 , +hy, -hz)\n glVertex3f(+sx, +hy, -hz)\n glVertex3f(+sx, -hy, -hz)\n glVertex3f(0 , -hy, -hz)\n\n # Right\n glNormal3f(0, 0, 1)\n glVertex3f(+sx, +hy, +hz)\n glVertex3f(0 , +hy, +hz)\n glVertex3f(0 , -hy, +hz)\n glVertex3f(+sx, -hy, +hz)\n\n # Top\n glNormal3f(0, 1, 0)\n glVertex3f(+sx, +hy, +hz)\n glVertex3f(+sx, +hy, -hz)\n glVertex3f(0 , +hy, -hz)\n glVertex3f(0 , +hy, +hz)\n\n # Bottom\n glNormal3f(0, -1, 0)\n glVertex3f(+sx, -hy, -hz)\n glVertex3f(+sx, -hy, +hz)\n glVertex3f(0 , -hy, +hz)\n glVertex3f(0 , -hy, -hz)\n\n glEnd()\n\n glPopMatrix()\n\nclass Box(Entity):\n \"\"\"\n Colored box object\n \"\"\"\n\n def __init__(self, color, size=1.0):\n super().__init__()\n\n if type(size) is int or type(size) is float:\n size = np.array([size, size, size])\n size = np.array(size)\n sx, sy, sz = size\n\n self.color = color\n self.size = size\n\n self.radius = math.sqrt(sx*sx + sz*sz)/2\n self.height = sy\n\n def randomize(self, params, rng):\n self.color_vec = COLORS[self.color] + params.sample(rng, 'obj_color_bias')\n self.color_vec = np.clip(self.color_vec, 0, 1)\n\n def render(self):\n \"\"\"\n Draw the object\n \"\"\"\n\n sx, sy, sz = self.size\n\n glDisable(GL_TEXTURE_2D)\n glColor3f(*self.color_vec)\n\n glPushMatrix()\n glTranslatef(*self.pos)\n glRotatef(self.dir * (180/math.pi), 0, 1, 0)\n\n drawBox(\n x_min=-sx/2,\n x_max=+sx/2,\n y_min=0,\n y_max=sy,\n z_min=-sz/2,\n z_max=+sz/2\n )\n\n glPopMatrix()\n\nclass Key(MeshEnt):\n \"\"\"\n Key the agent can pick up, carry, and use to open doors\n \"\"\"\n\n def __init__(self, color):\n assert color in COLOR_NAMES\n super().__init__(\n mesh_name='key_{}'.format(color),\n height=0.35,\n static=False\n )\n\nclass Ball(MeshEnt):\n \"\"\"\n Ball (sphere) the agent can pick up and carry\n \"\"\"\n\n def __init__(self, color, size=1.0):\n assert color in COLOR_NAMES\n super().__init__(\n mesh_name='ball_{}'.format(color),\n height=size,\n static=False\n )\n\nclass Office_desk(MeshEnt):\n \"\"\"\n Office Desk\n \"\"\"\n\n def __init__(self, size=1.0):\n super().__init__(\n mesh_name='office_desk',\n height=size,\n static=False\n )\n\nclass Office_chair(MeshEnt):\n \"\"\"\n Office Chair\n \"\"\"\n\n def __init__(self, size=1.0):\n super().__init__(\n mesh_name='office_chair',\n height=size,\n static=False\n )\n\nclass Potion(MeshEnt):\n \"\"\"\n Potion饮料\n \"\"\"\n\n def __init__(self, size=0.6):\n super().__init__(\n mesh_name='potion',\n height=size,\n static=False\n )\n\nclass Barrier(MeshEnt):\n \"\"\"\n Barrier\n \"\"\"\n\n def __init__(self, size=1.0):\n super().__init__(\n mesh_name='barrier',\n height=size,\n static=False\n )\n\nclass Agent(Entity):\n def __init__(self):\n super().__init__()\n\n # Distance between the camera and the floor\n self.cam_height = 1.5\n\n # Camera up/down angles in degrees\n # Positive angles tilt the camera upwards\n self.cam_pitch = 0\n\n # Vertical field of view in degrees\n self.cam_fov_y = 60\n\n # Bounding cylinder size for the agent\n self.radius = 0.4\n self.height = 1.6\n\n # Object currently being carried by the agent\n self.carrying = None\n\n @property\n def cam_pos(self):\n \"\"\"\n Camera position in 3D space\n \"\"\"\n\n rot_y = gen_rot_matrix(Y_VEC, self.dir)\n cam_disp = np.array([self.cam_fwd_disp, self.cam_height, 0])\n cam_disp = np.dot(cam_disp, rot_y)\n\n return self.pos + cam_disp\n\n @property\n def cam_dir(self):\n \"\"\"\n Camera direction (lookat) vector\n\n Note: this is useful even if just for slight domain\n randomization of camera angle\n \"\"\"\n\n rot_z = gen_rot_matrix(Z_VEC, self.cam_pitch * math.pi/180)\n rot_y = gen_rot_matrix(Y_VEC, self.dir)\n\n dir = np.dot(X_VEC, rot_z)\n dir = np.dot(dir, rot_y)\n\n return dir\n\n def randomize(self, params, rng):\n params.sample_many(rng, self, [\n 'cam_height',\n 'cam_fwd_disp',\n 'cam_pitch',\n 'cam_fov_y',\n ])\n # self.radius = params.sample(rng, 'bot_radius')\n\n def render(self):\n \"\"\"\n Draw the agent\n \"\"\"\n\n # Note: this is currently only used in the top view\n # Eventually, we will want a proper 3D model\n\n p = self.pos + Y_VEC * self.height\n dv = self.dir_vec * self.radius\n rv = self.right_vec * self.radius\n\n p0 = p + dv\n p1 = p + 0.75 * (rv - dv)\n p2 = p + 0.75 * (-rv - dv)\n\n glColor3f(1, 0, 0)\n glBegin(GL_TRIANGLES)\n glVertex3f(*p0)\n glVertex3f(*p2)\n glVertex3f(*p1)\n glEnd()\n\n \"\"\"\n glBegin(GL_LINE_STRIP)\n for i in range(20):\n a = (2 * math.pi * i) / 20\n pc = p + dv * math.cos(a) + rv * math.sin(a)\n glVertex3f(*pc)\n glEnd()\n \"\"\"\n\n def step(self, delta_time):\n pass\n"
] | [
[
"numpy.concatenate",
"numpy.array",
"numpy.linalg.norm",
"numpy.dot",
"numpy.sum",
"numpy.stack",
"numpy.greater",
"numpy.expand_dims",
"numpy.cross",
"numpy.insert",
"numpy.flip"
],
[
"numpy.array",
"numpy.dot",
"numpy.clip"
]
] |
Nitin-Mane/dense-ulearn-vos | [
"9e39d359a53a2343522ce5820fdf27223a4ffcb4"
] | [
"datasets/dataloader_infer.py"
] | [
"\"\"\"\nCopyright (c) 2021 TU Darmstadt\nAuthor: Nikita Araslanov <[email protected]>\nLicense: Apache License 2.0\n\"\"\"\n\nimport os\nimport torch\n\nfrom PIL import Image\n\nimport numpy as np\nimport torchvision.transforms as tf\n\nfrom .dataloader_base import DLBase\n\n\nclass DataSeg(DLBase):\n\n def __init__(self, cfg, split, ignore_labels=[], \\\n root=os.path.expanduser('./data'), renorm=False):\n\n super(DataSeg, self).__init__()\n\n self.cfg = cfg\n self.root = root\n self.split = split\n self.ignore_labels = ignore_labels\n self._init_palette(self.cfg.DATASET.NUM_CLASSES)\n\n # train/val/test splits are pre-cut\n split_fn = os.path.join(self.root, self.split + \".txt\")\n assert os.path.isfile(split_fn)\n\n self.sequence_ids = []\n self.sequence_names = []\n def add_sequence(name):\n vlen = len(self.images)\n assert vlen >= cfg.DATASET.VIDEO_LEN, \\\n \"Detected video shorter [{}] than training length [{}]\".format(vlen, \\\n cfg.DATASET.VIDEO_LEN)\n self.sequence_ids.append(vlen)\n self.sequence_names.append(name)\n return vlen\n\n self.images = []\n self.masks = []\n self.flags = []\n\n token = None\n with open(split_fn, \"r\") as lines:\n for line in lines:\n _flag, _image, _mask = line.strip(\"\\n\").split(' ')\n\n # save every frame\n #_flag = 1\n self.flags.append(int(_flag))\n\n _image = os.path.join(cfg.DATASET.ROOT, _image.lstrip('/'))\n assert os.path.isfile(_image), '%s not found' % _image\n\n # each sequence may have a different length\n # do some book-keeping e.g. to ensure we have\n # sequences long enough for subsequent sampling\n _token = _image.split(\"/\")[-2] # parent directory\n \n # sequence ID is in the filename\n #_token = os.path.basename(_image).split(\"_\")[0] \n if token != _token:\n if not token is None:\n add_sequence(token)\n token = _token\n\n self.images.append(_image)\n\n if _mask is None:\n self.masks.append(None)\n else:\n _mask = os.path.join(cfg.DATASET.ROOT, _mask.lstrip('/'))\n #assert os.path.isfile(_mask), '%s not found' % _mask\n self.masks.append(_mask)\n\n # update the last sequence\n # returns the total amount of frames\n add_sequence(token)\n print(\"Loaded {} sequences\".format(len(self.sequence_ids)))\n\n # definint data augmentation:\n print(\"Dataloader: {}\".format(split), \" #\", len(self.images))\n print(\"\\t {}: no augmentation\".format(split))\n\n self.tf = tf.Compose([tf.ToTensor(), tf.Normalize(mean=self.MEAN, std=self.STD)])\n self._num_samples = len(self.images)\n\n def __len__(self):\n return len(self.sequence_ids)\n\n \n def _mask2tensor(self, mask, num_classes=6):\n h,w = mask.shape\n ones = torch.ones(1,h,w)\n zeros = torch.zeros(num_classes,h,w)\n \n max_idx = mask.max()\n assert max_idx < num_classes, \"{} >= {}\".format(max_idx, num_classes)\n return zeros.scatter(0, mask[None, ...], ones)\n \n def denorm(self, image):\n\n if image.dim() == 3:\n assert image.dim() == 3, \"Expected image [CxHxW]\"\n assert image.size(0) == 3, \"Expected RGB image [3xHxW]\"\n\n for t, m, s in zip(image, self.MEAN, self.STD):\n t.mul_(s).add_(m)\n elif image.dim() == 4:\n # batch mode\n assert image.size(1) == 3, \"Expected RGB image [3xHxW]\"\n\n for t, m, s in zip((0,1,2), self.MEAN, self.STD):\n image[:, t, :, :].mul_(s).add_(m)\n\n return image\n\n\n def __getitem__(self, index):\n \n seq_to = self.sequence_ids[index]\n seq_from = 0 if index == 0 else self.sequence_ids[index - 1]\n\n image0 = Image.open(self.images[seq_from])\n w,h = image0.size\n\n images, masks, fns, flags = [], [], [], []\n tracks = torch.LongTensor(self.cfg.DATASET.NUM_CLASSES).fill_(-1)\n masks = torch.LongTensor(self.cfg.DATASET.NUM_CLASSES, h, w).zero_()\n known_ids = set()\n\n for t in range(seq_from, seq_to):\n\n t0 = t - seq_from\n image = Image.open(self.images[t]).convert('RGB')\n\n fns.append(os.path.basename(self.images[t].replace(\".jpg\", \"\")))\n flags.append(self.flags[t])\n\n if os.path.isfile(self.masks[t]):\n mask = Image.open(self.masks[t])\n mask = torch.from_numpy(np.array(mask, np.long, copy=False))\n\n unique_ids = np.unique(mask)\n for oid in unique_ids:\n if not oid in known_ids:\n tracks[oid] = t0\n known_ids.add(oid)\n masks[oid] = (mask == oid).long()\n else:\n mask = Image.new('L', image.size)\n\n image = self.tf(image)\n images.append(image)\n\n images = torch.stack(images, 0)\n seq_name = self.sequence_names[index]\n flags = torch.LongTensor(flags)\n\n return images, images, masks, tracks, len(known_ids), fns, flags, seq_name\n"
] | [
[
"torch.zeros",
"numpy.array",
"torch.stack",
"torch.ones",
"torch.LongTensor",
"numpy.unique"
]
] |
Carlosbogo/etna | [
"b6210f0e79ee92aa9ae8ff4fcfb267be9fb7cc94",
"b6210f0e79ee92aa9ae8ff4fcfb267be9fb7cc94",
"b6210f0e79ee92aa9ae8ff4fcfb267be9fb7cc94"
] | [
"etna/analysis/eda_utils.py",
"tests/test_transforms/test_feature_importance_transform.py",
"tests/test_pipeline/test_autoregressive_pipeline.py"
] | [
"import math\nimport warnings\nfrom itertools import combinations\nfrom typing import TYPE_CHECKING\nfrom typing import Optional\nfrom typing import Sequence\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport seaborn as sns\nimport statsmodels.api as sm\nfrom matplotlib.ticker import MaxNLocator\nfrom statsmodels.graphics import utils\n\nif TYPE_CHECKING:\n from etna.datasets import TSDataset\n\nplot_acf = sm.graphics.tsa.plot_acf\nplot_pacf = sm.graphics.tsa.plot_pacf\n\n\ndef cross_corr_plot(ts: \"TSDataset\", n_segments: int = 10, maxlags: int = 21, segments: Optional[Sequence] = None):\n \"\"\"\n Cross-correlation plot between multiple timeseries.\n\n Parameters\n ----------\n ts:\n TSDataset with timeseries data\n n_segments:\n number of random segments to plot\n maxlags:\n number of timeseries shifts for cross-correlation\n segments:\n segments to plot\n \"\"\"\n if not segments:\n segments = list(ts.segments)\n segments = np.random.choice(segments, size=min(len(segments), n_segments), replace=False)\n segment_pairs = list(combinations(segments, r=2))\n if len(segment_pairs) == 0:\n raise ValueError(\"There are no pairs to plot! Try set n_segments > 1.\")\n columns_num = min(2, len(segment_pairs))\n rows_num = math.ceil(len(segment_pairs) / columns_num)\n fig, ax = plt.subplots(rows_num, columns_num, figsize=(20, 5 * rows_num), constrained_layout=True, squeeze=False)\n ax = ax.ravel()\n fig.suptitle(\"Cross-correlation\", fontsize=16)\n for i, (segment_1, segment_2) in enumerate(segment_pairs):\n df_segment_1 = ts[:, segment_1, :][segment_1]\n df_segment_2 = ts[:, segment_2, :][segment_2]\n fig, axx = utils.create_mpl_ax(ax[i])\n target_1 = df_segment_1.target\n target_2 = df_segment_2.target\n if target_1.dtype == int or target_2.dtype == int:\n warnings.warn(\n \"At least one target column has integer dtype, \"\n \"it is converted to float in order to calculate correlation.\"\n )\n target_1 = target_1.astype(float)\n target_2 = target_2.astype(float)\n lags, level, _, _ = axx.xcorr(x=target_1, y=target_2, maxlags=maxlags)\n ax[i].plot(lags, level, \"o\", markersize=5)\n ax[i].set_title(f\"{segment_1} vs {segment_2}\")\n ax[i].xaxis.set_major_locator(MaxNLocator(integer=True))\n plt.show()\n\n\ndef sample_acf_plot(ts: \"TSDataset\", n_segments: int = 10, lags: int = 21, segments: Sequence = None):\n \"\"\"\n Autocorrelation plot for multiple timeseries.\n\n Parameters\n ----------\n ts:\n TSDataset with timeseries data\n n_segments:\n number of random segments to plot\n lags:\n number of timeseries shifts for cross-correlation\n segments:\n segments to plot\n\n Notes\n -----\n https://en.wikipedia.org/wiki/Autocorrelation\n \"\"\"\n if not segments:\n segments = sorted(ts.segments)\n\n k = min(n_segments, len(segments))\n columns_num = min(2, k)\n rows_num = math.ceil(k / columns_num)\n fig, ax = plt.subplots(rows_num, columns_num, figsize=(20, 5 * rows_num), constrained_layout=True, squeeze=False)\n ax = ax.ravel()\n fig.suptitle(\"Partial Autocorrelation\", fontsize=16)\n for i, name in enumerate(sorted(np.random.choice(segments, size=k, replace=False))):\n df_slice = ts[:, name, :][name]\n plot_acf(x=df_slice[\"target\"].values, ax=ax[i], lags=lags)\n ax[i].set_title(name)\n plt.show()\n\n\ndef sample_pacf_plot(ts: \"TSDataset\", n_segments: int = 10, lags: int = 21, segments: Sequence = None):\n \"\"\"\n Partial autocorrelation plot for multiple timeseries.\n\n Parameters\n ----------\n ts:\n TSDataset with timeseries data\n n_segments:\n number of random segments to plot\n lags:\n number of timeseries shifts for cross-correlation\n segments:\n segments to plot\n\n Notes\n -----\n https://en.wikipedia.org/wiki/Partial_autocorrelation_function\n \"\"\"\n if not segments:\n segments = sorted(ts.segments)\n\n k = min(n_segments, len(segments))\n columns_num = min(2, k)\n rows_num = math.ceil(k / columns_num)\n fig, ax = plt.subplots(rows_num, columns_num, figsize=(20, 5 * rows_num), constrained_layout=True, squeeze=False)\n ax = ax.ravel()\n fig.suptitle(\"Partial Autocorrelation\", fontsize=16)\n for i, name in enumerate(sorted(np.random.choice(segments, size=k, replace=False))):\n df_slice = ts[:, name, :][name]\n plot_pacf(x=df_slice[\"target\"].values, ax=ax[i], lags=lags)\n ax[i].set_title(name)\n plt.show()\n\n\ndef distribution_plot(\n ts: \"TSDataset\",\n n_segments: int = 10,\n segments: Sequence = None,\n shift: int = 30,\n window: int = 30,\n freq: str = \"1M\",\n n_rows: int = 10,\n):\n \"\"\"Distribution of z-values grouped by segments and time frequency.\n\n ... math:\n mean_{i} = \\\\sum_{j=i-\\\\text{shift}}^{i-\\\\text{shift}+\\\\text{window}} \\\\frac{x_{j}}{\\\\text{window}}\n\n Parameters\n ----------\n ts:\n dataset with timeseries data\n n_segments:\n number of random segments to plot\n segments:\n segments to plot\n shift:\n number of timeseries shifts for statistics calc\n window:\n number of points for statistics calc\n freq:\n group for z_{i}\n n_rows:\n maximum number of rows to plot\n \"\"\"\n df_pd = ts.to_pandas(flatten=True)\n\n if not segments:\n segments = df_pd.segment.unique()\n segments = np.random.choice(segments, size=min(len(segments), n_segments), replace=False)\n df_full = df_pd[df_pd.segment.isin(segments)]\n df_full.loc[:, \"mean\"] = (\n df_full.groupby(\"segment\").target.shift(shift).transform(lambda s: s.rolling(window).mean())\n )\n df_full.loc[:, \"std\"] = df_full.groupby(\"segment\").target.shift(shift).transform(lambda s: s.rolling(window).std())\n df_full = df_full.dropna()\n df_full.loc[:, \"z\"] = (df_full[\"target\"] - df_full[\"mean\"]) / df_full[\"std\"]\n\n grouped_data = df_full.groupby([df_full.timestamp.dt.to_period(freq)])\n columns_num = min(2, len(grouped_data))\n rows_num = min(n_rows, math.ceil(len(grouped_data) / columns_num))\n groups = set(list(grouped_data.groups.keys())[-rows_num * columns_num :])\n fig, ax = plt.subplots(rows_num, columns_num, figsize=(20, 7.5 * rows_num), constrained_layout=True, squeeze=False)\n fig.suptitle(f\"Z statistic shift: {shift} window: {window}\", fontsize=16)\n ax = ax.ravel()\n i = 0\n for period, df_slice in grouped_data:\n if period not in groups:\n continue\n sns.boxplot(data=df_slice.sort_values(by=\"segment\"), y=\"z\", x=\"segment\", ax=ax[i], fliersize=False)\n ax[i].set_title(f\"{period}\")\n i += 1\n",
"import pandas as pd\nimport pytest\nfrom catboost import CatBoostRegressor\nfrom numpy.random import RandomState\nfrom sklearn.ensemble import ExtraTreesRegressor\nfrom sklearn.ensemble import GradientBoostingRegressor\nfrom sklearn.ensemble import RandomForestRegressor\nfrom sklearn.metrics import r2_score\nfrom sklearn.tree import DecisionTreeRegressor\nfrom sklearn.tree import ExtraTreeRegressor\n\nfrom etna.datasets import TSDataset\nfrom etna.datasets import generate_ar_df\nfrom etna.models import LinearPerSegmentModel\nfrom etna.pipeline import Pipeline\nfrom etna.transforms import SegmentEncoderTransform\nfrom etna.transforms.feature_importance import TreeFeatureSelectionTransform\n\n\[email protected]\ndef ts_with_regressors():\n num_segments = 3\n df = generate_ar_df(\n start_time=\"2020-01-01\", periods=300, ar_coef=[1], sigma=1, n_segments=num_segments, random_seed=0, freq=\"D\"\n )\n\n example_segment = df[\"segment\"].unique()[0]\n timestamp = df[df[\"segment\"] == example_segment][\"timestamp\"]\n df_exog = pd.DataFrame({\"timestamp\": timestamp})\n\n # useless regressors\n num_useless = 12\n df_regressors_useless = generate_ar_df(\n start_time=\"2020-01-01\", periods=300, ar_coef=[1], sigma=1, n_segments=num_useless, random_seed=1, freq=\"D\"\n )\n for i, segment in enumerate(df_regressors_useless[\"segment\"].unique()):\n regressor = df_regressors_useless[df_regressors_useless[\"segment\"] == segment][\"target\"].values\n df_exog[f\"regressor_useless_{i}\"] = regressor\n\n # useful regressors: the same as target but with little noise\n df_regressors_useful = df.copy()\n sampler = RandomState(seed=2).normal\n for i, segment in enumerate(df_regressors_useful[\"segment\"].unique()):\n regressor = df_regressors_useful[df_regressors_useful[\"segment\"] == segment][\"target\"].values\n noise = sampler(scale=0.05, size=regressor.shape)\n df_exog[f\"regressor_useful_{i}\"] = regressor + noise\n\n # construct exog\n classic_exog_list = []\n for segment in df[\"segment\"].unique():\n tmp = df_exog.copy(deep=True)\n tmp[\"segment\"] = segment\n classic_exog_list.append(tmp)\n df_exog_all_segments = pd.concat(classic_exog_list)\n\n # construct TSDataset\n df = df[df[\"timestamp\"] <= timestamp[200]]\n return TSDataset(df=TSDataset.to_dataset(df), df_exog=TSDataset.to_dataset(df_exog_all_segments), freq=\"D\")\n\n\[email protected](\n \"model\",\n [\n DecisionTreeRegressor(random_state=42),\n ExtraTreeRegressor(random_state=42),\n RandomForestRegressor(n_estimators=10, random_state=42),\n ExtraTreesRegressor(n_estimators=10, random_state=42),\n GradientBoostingRegressor(n_estimators=10, random_state=42),\n CatBoostRegressor(iterations=10, random_state=42, silent=True, cat_features=[\"regressor_segment_code\"]),\n ],\n)\[email protected](\"top_k\", [0, 1, 5, 15, 50])\ndef test_selected_top_k_regressors(model, top_k, ts_with_regressors):\n \"\"\"Check that transform selects exactly top_k regressors if where are this much.\"\"\"\n df = ts_with_regressors.to_pandas()\n le_encoder = SegmentEncoderTransform()\n df_encoded = le_encoder.fit_transform(df)\n selector = TreeFeatureSelectionTransform(model=model, top_k=top_k)\n df_selected = selector.fit_transform(df_encoded)\n\n all_regressors = ts_with_regressors.regressors\n all_regressors.append(\"regressor_segment_code\")\n selected_regressors = set()\n for column in df_selected.columns.get_level_values(\"feature\"):\n if column.startswith(\"regressor\"):\n selected_regressors.add(column)\n\n assert len(selected_regressors) == min(len(all_regressors), top_k)\n\n\[email protected](\n \"model\",\n [\n DecisionTreeRegressor(random_state=42),\n ExtraTreeRegressor(random_state=42),\n RandomForestRegressor(n_estimators=10, random_state=42),\n ExtraTreesRegressor(n_estimators=10, random_state=42),\n GradientBoostingRegressor(n_estimators=10, random_state=42),\n CatBoostRegressor(iterations=10, random_state=42, silent=True, cat_features=[\"regressor_segment_code\"]),\n ],\n)\[email protected](\"top_k\", [0, 1, 5, 15, 50])\ndef test_retain_values(model, top_k, ts_with_regressors):\n \"\"\"Check that transform doesn't change values of columns.\"\"\"\n df = ts_with_regressors.to_pandas()\n le_encoder = SegmentEncoderTransform()\n df_encoded = le_encoder.fit_transform(df)\n selector = TreeFeatureSelectionTransform(model=model, top_k=top_k)\n df_selected = selector.fit_transform(df_encoded)\n\n for segment in ts_with_regressors.segments:\n for column in df_selected.columns.get_level_values(\"feature\").unique():\n assert (\n df_selected.loc[:, pd.IndexSlice[segment, column]] == df_encoded.loc[:, pd.IndexSlice[segment, column]]\n ).all()\n\n\[email protected](\n \"model\",\n [\n DecisionTreeRegressor(random_state=42),\n ExtraTreeRegressor(random_state=42),\n RandomForestRegressor(n_estimators=10, random_state=42),\n ExtraTreesRegressor(n_estimators=10, random_state=42),\n GradientBoostingRegressor(n_estimators=10, random_state=42),\n CatBoostRegressor(iterations=10, random_state=42, silent=True, cat_features=[\"regressor_segment_code\"]),\n ],\n)\ndef test_fails_negative_top_k(model, ts_with_regressors):\n \"\"\"Check that transform doesn't allow you to set top_k to negative values.\"\"\"\n with pytest.raises(ValueError, match=\"positive integer\"):\n TreeFeatureSelectionTransform(model=model, top_k=-1)\n\n\[email protected](\n \"model\",\n [\n DecisionTreeRegressor(random_state=42),\n ExtraTreeRegressor(random_state=42),\n RandomForestRegressor(n_estimators=10, random_state=42),\n ExtraTreesRegressor(n_estimators=10, random_state=42),\n GradientBoostingRegressor(n_estimators=10, random_state=42),\n CatBoostRegressor(iterations=10, random_state=42, silent=True),\n ],\n)\ndef test_warns_no_regressors(model, example_tsds):\n \"\"\"Check that transform allows you to fit on dataset with no regressors but warns about it.\"\"\"\n df = example_tsds.to_pandas()\n selector = TreeFeatureSelectionTransform(model=model, top_k=3)\n with pytest.warns(UserWarning, match=\"not possible to select regressors\"):\n df_selected = selector.fit_transform(df)\n assert (df == df_selected).all().all()\n\n\[email protected](\n \"model\",\n [\n DecisionTreeRegressor(random_state=42),\n ExtraTreeRegressor(random_state=42),\n RandomForestRegressor(n_estimators=10, random_state=42),\n ExtraTreesRegressor(n_estimators=10, random_state=42),\n GradientBoostingRegressor(n_estimators=10, random_state=42),\n CatBoostRegressor(iterations=700, random_state=42, silent=True, cat_features=[\"regressor_segment_code\"]),\n ],\n)\ndef test_sanity_selected(model, ts_with_regressors):\n \"\"\"Check that transform correctly finds meaningful regressors.\"\"\"\n df = ts_with_regressors.to_pandas()\n le_encoder = SegmentEncoderTransform()\n df_encoded = le_encoder.fit_transform(df)\n selector = TreeFeatureSelectionTransform(model=model, top_k=8)\n df_selected = selector.fit_transform(df_encoded)\n features_columns = df_selected.columns.get_level_values(\"feature\").unique()\n selected_regressors = [column for column in features_columns if column.startswith(\"regressor_\")]\n useful_regressors = [column for column in selected_regressors if \"useful\" in column]\n assert len(useful_regressors) == 3\n\n\[email protected](\n \"model\",\n [\n DecisionTreeRegressor(random_state=42),\n ExtraTreeRegressor(random_state=42),\n RandomForestRegressor(n_estimators=10, random_state=42),\n ExtraTreesRegressor(n_estimators=10, random_state=42),\n GradientBoostingRegressor(n_estimators=10, random_state=42),\n CatBoostRegressor(iterations=500, silent=True, random_state=42, cat_features=[\"regressor_segment_code\"]),\n ],\n)\ndef test_sanity_model(model, ts_with_regressors):\n \"\"\"Check that training with this transform can utilize selected regressors.\"\"\"\n ts_train, ts_test = ts_with_regressors.train_test_split(test_size=30)\n le_encoder = SegmentEncoderTransform()\n selector = TreeFeatureSelectionTransform(model=model, top_k=8)\n\n model = LinearPerSegmentModel()\n pipeline = Pipeline(model=model, transforms=[le_encoder, selector], horizon=30)\n pipeline.fit(ts=ts_train)\n ts_forecast = pipeline.forecast()\n\n for segment in ts_forecast.segments:\n test_target = ts_test[:, segment, \"target\"]\n forecasted_target = ts_forecast[:, segment, \"target\"]\n r2 = r2_score(forecasted_target, test_target)\n assert r2 > 0.99\n",
"from copy import deepcopy\n\nimport numpy as np\nimport pandas as pd\nimport pytest\n\nfrom etna.datasets import TSDataset\nfrom etna.models import LinearPerSegmentModel\nfrom etna.pipeline import AutoRegressivePipeline\nfrom etna.transforms import DateFlagsTransform\nfrom etna.transforms import LagTransform\nfrom etna.transforms import LinearTrendTransform\n\n\ndef test_fit(example_tsds):\n \"\"\"Test that AutoRegressivePipeline pipeline makes fit without failing.\"\"\"\n model = LinearPerSegmentModel()\n transforms = [LagTransform(in_column=\"target\", lags=[1]), DateFlagsTransform()]\n pipeline = AutoRegressivePipeline(model=model, transforms=transforms, horizon=5, step=1)\n pipeline.fit(example_tsds)\n\n\ndef test_forecast_columns(example_tsds):\n \"\"\"Test that AutoRegressivePipeline generates all the columns.\"\"\"\n original_ts = deepcopy(example_tsds)\n horizon = 5\n\n # make predictions in AutoRegressivePipeline\n model = LinearPerSegmentModel()\n transforms = [LagTransform(in_column=\"target\", lags=[1]), DateFlagsTransform(is_weekend=True)]\n pipeline = AutoRegressivePipeline(model=model, transforms=transforms, horizon=horizon, step=1)\n pipeline.fit(example_tsds)\n forecast_pipeline = pipeline.forecast()\n\n # generate all columns\n original_ts.fit_transform(transforms)\n\n assert set(forecast_pipeline.columns) == set(original_ts.columns)\n\n\ndef test_forecast_one_step(example_tsds):\n \"\"\"Test that AutoRegressivePipeline gets predictions one by one if step is equal to 1.\"\"\"\n original_ts = deepcopy(example_tsds)\n horizon = 5\n\n # make predictions in AutoRegressivePipeline\n model = LinearPerSegmentModel()\n transforms = [LagTransform(in_column=\"target\", lags=[1])]\n pipeline = AutoRegressivePipeline(model=model, transforms=transforms, horizon=horizon, step=1)\n pipeline.fit(example_tsds)\n forecast_pipeline = pipeline.forecast()\n\n # make predictions manually\n df = original_ts.to_pandas()\n original_ts.fit_transform(transforms)\n model = LinearPerSegmentModel()\n model.fit(original_ts)\n for i in range(horizon):\n cur_ts = TSDataset(df, freq=original_ts.freq)\n # these transform don't fit and we can fit_transform them at each step\n cur_ts.transform(transforms)\n cur_forecast_ts = cur_ts.make_future(1)\n cur_future_ts = model.forecast(cur_forecast_ts)\n to_add_df = cur_future_ts.to_pandas()\n df = pd.concat([df, to_add_df[df.columns]])\n\n forecast_manual = TSDataset(df.tail(horizon), freq=original_ts.freq)\n assert np.all(forecast_pipeline[:, :, \"target\"] == forecast_manual[:, :, \"target\"])\n\n\[email protected](\"horizon, step\", ((1, 1), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (20, 1), (20, 2), (20, 3)))\ndef test_forecast_multi_step(example_tsds, horizon, step):\n \"\"\"Test that AutoRegressivePipeline gets correct number of predictions if step is more than 1.\"\"\"\n model = LinearPerSegmentModel()\n transforms = [LagTransform(in_column=\"target\", lags=[step])]\n pipeline = AutoRegressivePipeline(model=model, transforms=transforms, horizon=horizon, step=step)\n pipeline.fit(example_tsds)\n forecast_pipeline = pipeline.forecast()\n\n assert forecast_pipeline.df.shape[0] == horizon\n\n\ndef test_forecast_warning_prediction_intervals(example_tsds):\n \"\"\"Test that AutoRegressivePipeline warns when called with prediction intervals.\"\"\"\n horizon = 5\n step = 1\n model = LinearPerSegmentModel()\n transforms = [LagTransform(in_column=\"target\", lags=[step])]\n pipeline = AutoRegressivePipeline(model=model, transforms=transforms, horizon=horizon, step=step)\n pipeline.fit(example_tsds)\n with pytest.warns(UserWarning, match=\"doesn't support prediction intervals\"):\n _ = pipeline.forecast(prediction_interval=True)\n\n\ndef test_forecast_with_fit_transforms(example_tsds):\n \"\"\"Test that AutoRegressivePipeline can work with transforms that need fitting.\"\"\"\n horizon = 5\n\n model = LinearPerSegmentModel()\n transforms = [LagTransform(in_column=\"target\", lags=[1]), LinearTrendTransform(in_column=\"target\")]\n pipeline = AutoRegressivePipeline(model=model, transforms=transforms, horizon=horizon, step=1)\n pipeline.fit(example_tsds)\n pipeline.forecast()\n"
] | [
[
"matplotlib.pyplot.show",
"numpy.random.choice",
"matplotlib.ticker.MaxNLocator",
"matplotlib.pyplot.subplots"
],
[
"sklearn.ensemble.GradientBoostingRegressor",
"numpy.random.RandomState",
"pandas.concat",
"pandas.DataFrame",
"sklearn.ensemble.ExtraTreesRegressor",
"sklearn.tree.ExtraTreeRegressor",
"sklearn.ensemble.RandomForestRegressor",
"sklearn.tree.DecisionTreeRegressor",
"sklearn.metrics.r2_score"
],
[
"numpy.all",
"pandas.concat"
]
] |
TimoleonLatinopoulos/MortalKombatOpenAI | [
"59dc89d1f50dd74690859e5e1fa18701a5246382"
] | [
"DDQN.py"
] | [
"import tensorflow as tf\nfrom keras.activations import relu\nfrom keras.initializers import VarianceScaling\nfrom keras.layers import Dense, Conv2D, Flatten\nfrom keras.losses import logcosh\n\n\nclass DDQN:\n \"\"\" Implements a Dueling Dual Deep Q-Network based on the frames of the Retro Environment \"\"\"\n\n def __init__(self, n_actions, frame_height=63, frame_width=113, stacked_frames=4, learning_rate=0.00001):\n self.n_actions = n_actions\n self.frame_height = frame_height\n self.frame_width = frame_width\n self.stacked_frames = stacked_frames\n self.learning_rate = learning_rate\n\n self.input = tf.placeholder(shape=[None, self.frame_height, self.frame_width, self.stacked_frames],\n dtype=tf.float32)\n self.input = self.input / 255\n\n # Convolutional layers\n self.conv1 = self.conv_layer(self.input, 32, [8, 8], 4, 'conv1')\n self.conv2 = self.conv_layer(self.conv1, 64, [4, 4], 2, 'conv2')\n self.conv3 = self.conv_layer(self.conv2, 64, [3, 3], 1, 'conv3')\n self.flat = Flatten()(self.conv3)\n self.dense1 = self.dense_layer(self.flat, 512, 'dense1', relu)\n\n # Splitting into value and advantage streams\n self.v_stream, self.a_stream = tf.split(self.dense1, 2, 1)\n self.value = self.dense_layer(self.v_stream, 1, 'value')\n self.advantage = self.dense_layer(self.a_stream, self.n_actions, 'advantage')\n\n # Getting Q-values from value and advantage streams\n self.q_values = self.value + tf.subtract(self.advantage, tf.reduce_mean(self.advantage, axis=1, keepdims=True))\n self.prediction = tf.argmax(self.q_values, 1)\n\n # targetQ according to Bellman equation\n self.target_q = tf.placeholder(shape=[None], dtype=tf.float32)\n self.action = tf.placeholder(shape=[None], dtype=tf.uint8)\n self.action_one_hot = tf.one_hot(self.action, self.n_actions, dtype=tf.float32)\n self.Q = tf.reduce_sum(tf.multiply(self.q_values, self.action_one_hot), axis=1)\n\n # Parameter updates\n self.error = logcosh(self.target_q, self.Q)\n self.loss = tf.reduce_mean(self.error)\n self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate)\n self.update = self.optimizer.minimize(self.loss)\n\n @staticmethod\n def conv_layer(_inputs, _filters, _kernel_size, _strides, _name):\n return Conv2D(filters=_filters, kernel_size=_kernel_size, strides=_strides,\n kernel_initializer=VarianceScaling(scale=2.0), padding=\"valid\",\n activation=relu, use_bias=False, name=_name)(_inputs)\n\n @staticmethod\n def dense_layer(_inputs, _units, _name, _activation=None):\n return Dense(activation=_activation, units=_units,\n kernel_initializer=VarianceScaling(scale=2.0), name=_name)(_inputs)\n\n\nclass TargetNetworkUpdater:\n \"\"\" Updates the variables and the weights of the target network based on the main network \"\"\"\n\n def __init__(self, main_vars, target_vars):\n self.main_vars = main_vars\n self.target_vars = target_vars\n\n def update_target_vars(self):\n update_ops = []\n for i, var in enumerate(self.main_vars):\n copy_op = self.target_vars[i].assign(var.value())\n update_ops.append(copy_op)\n return update_ops\n\n def update_networks(self, sess):\n update_ops = self.update_target_vars()\n for copy_op in update_ops:\n sess.run(copy_op)\n"
] | [
[
"tensorflow.multiply",
"tensorflow.train.AdamOptimizer",
"tensorflow.argmax",
"tensorflow.placeholder",
"tensorflow.split",
"tensorflow.one_hot",
"tensorflow.reduce_mean"
]
] |
meokz/d3rlpy | [
"40504e2d8b424547558ab82786c523e8f4626a82"
] | [
"d3rlpy/models/torch/encoders.py"
] | [
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n\ndef _create_activation(activation_type):\n if activation_type == 'relu':\n return torch.relu\n elif activation_type == 'swish':\n return lambda x: x * torch.sigmoid(x)\n raise ValueError('invalid activation_type.')\n\n\ndef create_encoder(observation_shape,\n action_size=None,\n use_batch_norm=False,\n discrete_action=False,\n activation_type='relu',\n **kwargs):\n\n activation = _create_activation(activation_type)\n\n if len(observation_shape) == 3:\n # pixel input\n if action_size is not None:\n return PixelEncoderWithAction(observation_shape,\n action_size,\n use_batch_norm=use_batch_norm,\n discrete_action=discrete_action,\n activation=activation,\n **kwargs)\n return PixelEncoder(observation_shape,\n use_batch_norm=use_batch_norm,\n activation=activation,\n **kwargs)\n elif len(observation_shape) == 1:\n # vector input\n if action_size is not None:\n return VectorEncoderWithAction(observation_shape,\n action_size,\n use_batch_norm=use_batch_norm,\n discrete_action=discrete_action,\n activation=activation,\n **kwargs)\n return VectorEncoder(observation_shape,\n use_batch_norm=use_batch_norm,\n activation=activation,\n **kwargs)\n else:\n raise ValueError('observation_shape must be 1d or 3d.')\n\n\nclass PixelEncoder(nn.Module):\n def __init__(self,\n observation_shape,\n filters=None,\n feature_size=None,\n use_batch_norm=False,\n activation=torch.relu):\n super().__init__()\n\n # default architecture is based on Nature DQN paper.\n if filters is None:\n filters = [(32, 8, 4), (64, 4, 2), (64, 3, 1)]\n if feature_size is None:\n feature_size = 512\n\n self.observation_shape = observation_shape\n self.use_batch_norm = use_batch_norm\n self.activation = activation\n self.feature_size = feature_size\n\n # convolutional layers\n in_channels = [observation_shape[0]] + [f[0] for f in filters[:-1]]\n self.convs = nn.ModuleList()\n self.conv_bns = nn.ModuleList()\n for in_channel, f in zip(in_channels, filters):\n out_channel, kernel_size, stride = f\n conv = nn.Conv2d(in_channel,\n out_channel,\n kernel_size=kernel_size,\n stride=stride)\n self.convs.append(conv)\n\n if use_batch_norm:\n self.conv_bns.append(nn.BatchNorm2d(out_channel))\n\n # last dense layer\n self.fc = nn.Linear(self._get_linear_input_size(), feature_size)\n if use_batch_norm:\n self.fc_bn = nn.BatchNorm1d(feature_size)\n\n def _get_linear_input_size(self):\n x = torch.rand((1, ) + self.observation_shape)\n with torch.no_grad():\n return self._conv_encode(x).view(1, -1).shape[1]\n\n def _conv_encode(self, x):\n h = x\n for i in range(len(self.convs)):\n h = self.activation(self.convs[i](h))\n if self.use_batch_norm:\n h = self.conv_bns[i](h)\n return h\n\n def forward(self, x):\n h = self._conv_encode(x)\n\n h = self.activation(self.fc(h.view(h.shape[0], -1)))\n if self.use_batch_norm:\n h = self.fc_bn(h)\n\n return h\n\n\nclass PixelEncoderWithAction(PixelEncoder):\n def __init__(self,\n observation_shape,\n action_size,\n filters=None,\n feature_size=None,\n use_batch_norm=False,\n discrete_action=False,\n activation=torch.relu):\n self.action_size = action_size\n self.discrete_action = discrete_action\n super().__init__(observation_shape, filters, feature_size,\n use_batch_norm, activation)\n\n def _get_linear_input_size(self):\n size = super()._get_linear_input_size()\n return size + self.action_size\n\n def forward(self, x, action):\n h = self._conv_encode(x)\n\n if self.discrete_action:\n action = F.one_hot(action.view(-1).long(),\n num_classes=self.action_size).float()\n\n # cocat feature and action\n h = torch.cat([h.view(h.shape[0], -1), action], dim=1)\n h = self.activation(self.fc(h))\n if self.use_batch_norm:\n h = self.fc_bn(h)\n\n return h\n\n\nclass VectorEncoder(nn.Module):\n def __init__(self,\n observation_shape,\n hidden_units=None,\n use_batch_norm=False,\n activation=torch.relu):\n super().__init__()\n self.observation_shape = observation_shape\n\n if hidden_units is None:\n hidden_units = [256, 256]\n\n self.use_batch_norm = use_batch_norm\n self.feature_size = hidden_units[-1]\n self.activation = activation\n\n in_units = [observation_shape[0]] + hidden_units[:-1]\n self.fcs = nn.ModuleList()\n self.bns = nn.ModuleList()\n for in_unit, out_unit in zip(in_units, hidden_units):\n self.fcs.append(nn.Linear(in_unit, out_unit))\n if use_batch_norm:\n self.bns.append(nn.BatchNorm1d(out_unit))\n\n def forward(self, x):\n h = x\n for i in range(len(self.fcs)):\n h = self.activation(self.fcs[i](h))\n if self.use_batch_norm:\n h = self.bns[i](h)\n return h\n\n\nclass VectorEncoderWithAction(VectorEncoder):\n def __init__(self,\n observation_shape,\n action_size,\n hidden_units=None,\n use_batch_norm=False,\n discrete_action=False,\n activation=torch.relu):\n self.action_size = action_size\n self.discrete_action = discrete_action\n concat_shape = (observation_shape[0] + action_size, )\n super().__init__(concat_shape, hidden_units, use_batch_norm,\n activation)\n self.observation_shape = observation_shape\n\n def forward(self, x, action):\n if self.discrete_action:\n action = F.one_hot(action.view(-1).long(),\n num_classes=self.action_size).float()\n\n x = torch.cat([x, action], dim=1)\n return super().forward(x)\n"
] | [
[
"torch.nn.Linear",
"torch.rand",
"torch.cat",
"torch.sigmoid",
"torch.nn.ModuleList",
"torch.no_grad",
"torch.nn.BatchNorm2d",
"torch.nn.Conv2d",
"torch.nn.BatchNorm1d"
]
] |
NLP-Discourse-SoochowU/TDDiscourseParser | [
"2f9c7cef85c564c47b368ee4935caf1fad7c598d"
] | [
"treebuilder/partptr/train.py"
] | [
"# coding: UTF-8\r\nimport argparse\r\nimport logging\r\nimport random\r\nimport torch\r\nimport copy\r\nimport numpy as np\r\nfrom dataset import CDTB\r\nfrom collections import Counter\r\nfrom itertools import chain\r\nfrom structure.vocab import Vocab, Label\r\nfrom structure.nodes import node_type_filter, EDU, Relation, Sentence, TEXT\r\nfrom treebuilder.partptr.model import PartitionPtr\r\nfrom treebuilder.partptr.parser import PartitionPtrParser\r\nimport torch.optim as optim\r\nfrom util.eval import parse_eval, gen_parse_report\r\nfrom tensorboardX import SummaryWriter\r\n\r\n\r\ndef build_vocab(dataset):\r\n word_freq = Counter()\r\n pos_freq = Counter()\r\n nuc_freq = Counter()\r\n rel_freq = Counter()\r\n for paragraph in chain(*dataset):\r\n for node in paragraph.iterfind(filter=node_type_filter([EDU, Relation])):\r\n if isinstance(node, EDU):\r\n word_freq.update(node.words)\r\n pos_freq.update(node.tags)\r\n elif isinstance(node, Relation):\r\n nuc_freq[node.nuclear] += 1\r\n rel_freq[node.ftype] += 1\r\n\r\n word_vocab = Vocab(\"word\", word_freq)\r\n pos_vocab = Vocab(\"part of speech\", pos_freq)\r\n nuc_label = Label(\"nuclear\", nuc_freq)\r\n rel_label = Label(\"relation\", rel_freq)\r\n return word_vocab, pos_vocab, nuc_label, rel_label\r\n\r\n\r\ndef gen_decoder_data(root, edu2ids):\r\n # splits s0 s1 s2 s3 s4 s5 s6\r\n # edus s/ e0 e1 e2 e3 e4 e5 /s\r\n splits = [] # [(0, 3, 6, NS), (0, 2, 3, SN), ...]\r\n child_edus = [] # [edus]\r\n\r\n if isinstance(root, EDU):\r\n child_edus.append(root)\r\n elif isinstance(root, Sentence):\r\n for child in root:\r\n _child_edus, _splits = gen_decoder_data(child, edu2ids)\r\n child_edus.extend(_child_edus)\r\n splits.extend(_splits)\r\n elif isinstance(root, Relation):\r\n children = [gen_decoder_data(child, edu2ids) for child in root]\r\n if len(children) < 2:\r\n raise ValueError(\"relation node should have at least 2 children\")\r\n\r\n while children:\r\n left_child_edus, left_child_splits = children.pop(0)\r\n if children:\r\n last_child_edus, _ = children[-1]\r\n start = edu2ids[left_child_edus[0]]\r\n split = edu2ids[left_child_edus[-1]] + 1\r\n end = edu2ids[last_child_edus[-1]] + 1\r\n nuc = root.nuclear\r\n rel = root.ftype\r\n splits.append((start, split, end, nuc, rel))\r\n child_edus.extend(left_child_edus)\r\n splits.extend(left_child_splits)\r\n return child_edus, splits\r\n\r\n\r\ndef numericalize(dataset, word_vocab, pos_vocab, nuc_label, rel_label):\r\n instances = []\r\n for paragraph in filter(lambda d: d.root_relation(), chain(*dataset)):\r\n encoder_inputs = []\r\n decoder_inputs = []\r\n pred_splits = []\r\n pred_nucs = []\r\n pred_rels = []\r\n edus = list(paragraph.edus())\r\n for edu in edus:\r\n edu_word_ids = [word_vocab[word] for word in edu.words]\r\n edu_pos_ids = [pos_vocab[pos] for pos in edu.tags]\r\n encoder_inputs.append((edu_word_ids, edu_pos_ids))\r\n edu2ids = {edu: i for i, edu in enumerate(edus)}\r\n _, splits = gen_decoder_data(paragraph.root_relation(), edu2ids)\r\n for start, split, end, nuc, rel in splits:\r\n decoder_inputs.append((start, end))\r\n pred_splits.append(split)\r\n pred_nucs.append(nuc_label[nuc])\r\n pred_rels.append(rel_label[rel])\r\n instances.append((encoder_inputs, decoder_inputs, pred_splits, pred_nucs, pred_rels))\r\n return instances\r\n\r\n\r\ndef gen_batch_iter(instances, batch_size, use_gpu=False):\r\n random_instances = np.random.permutation(instances)\r\n num_instances = len(instances)\r\n offset = 0\r\n while offset < num_instances:\r\n batch = random_instances[offset: min(num_instances, offset+batch_size)]\r\n\r\n # find out max seqlen of edus and words of edus\r\n num_batch = batch.shape[0]\r\n max_edu_seqlen = 0\r\n max_word_seqlen = 0\r\n for encoder_inputs, decoder_inputs, pred_splits, pred_nucs, pred_rels in batch:\r\n max_edu_seqlen = max_edu_seqlen if max_edu_seqlen >= len(encoder_inputs) else len(encoder_inputs)\r\n for edu_word_ids, edu_pos_ids in encoder_inputs:\r\n max_word_seqlen = max_word_seqlen if max_word_seqlen >= len(edu_word_ids) else len(edu_word_ids)\r\n\r\n # batch to numpy\r\n e_input_words = np.zeros([num_batch, max_edu_seqlen, max_word_seqlen], dtype=np.long)\r\n e_input_poses = np.zeros([num_batch, max_edu_seqlen, max_word_seqlen], dtype=np.long)\r\n e_masks = np.zeros([num_batch, max_edu_seqlen, max_word_seqlen], dtype=np.uint8)\r\n\r\n d_inputs = np.zeros([num_batch, max_edu_seqlen-1, 2], dtype=np.long)\r\n d_outputs = np.zeros([num_batch, max_edu_seqlen-1], dtype=np.long)\r\n d_output_nucs = np.zeros([num_batch, max_edu_seqlen-1], dtype=np.long)\r\n d_output_rels = np.zeros([num_batch, max_edu_seqlen - 1], dtype=np.long)\r\n d_masks = np.zeros([num_batch, max_edu_seqlen-1, max_edu_seqlen+1], dtype=np.uint8)\r\n\r\n for batchi, (encoder_inputs, decoder_inputs, pred_splits, pred_nucs, pred_rels) in enumerate(batch):\r\n for edui, (edu_word_ids, edu_pos_ids) in enumerate(encoder_inputs):\r\n word_seqlen = len(edu_word_ids)\r\n e_input_words[batchi][edui][:word_seqlen] = edu_word_ids\r\n e_input_poses[batchi][edui][:word_seqlen] = edu_pos_ids\r\n e_masks[batchi][edui][:word_seqlen] = 1\r\n\r\n for di, decoder_input in enumerate(decoder_inputs):\r\n d_inputs[batchi][di] = decoder_input\r\n d_masks[batchi][di][decoder_input[0]+1: decoder_input[1]] = 1\r\n d_outputs[batchi][:len(pred_splits)] = pred_splits\r\n d_output_nucs[batchi][:len(pred_nucs)] = pred_nucs\r\n d_output_rels[batchi][:len(pred_rels)] = pred_rels\r\n\r\n # numpy to torch\r\n e_input_words = torch.from_numpy(e_input_words).long()\r\n e_input_poses = torch.from_numpy(e_input_poses).long()\r\n e_masks = torch.from_numpy(e_masks).byte()\r\n d_inputs = torch.from_numpy(d_inputs).long()\r\n d_outputs = torch.from_numpy(d_outputs).long()\r\n d_output_nucs = torch.from_numpy(d_output_nucs).long()\r\n d_output_rels = torch.from_numpy(d_output_rels).long()\r\n d_masks = torch.from_numpy(d_masks).byte()\r\n\r\n if use_gpu:\r\n e_input_words = e_input_words.cuda()\r\n e_input_poses = e_input_poses.cuda()\r\n e_masks = e_masks.cuda()\r\n d_inputs = d_inputs.cuda()\r\n d_outputs = d_outputs.cuda()\r\n d_output_nucs = d_output_nucs.cuda()\r\n d_output_rels = d_output_rels.cuda()\r\n d_masks = d_masks.cuda()\r\n\r\n yield (e_input_words, e_input_poses, e_masks), (d_inputs, d_masks), (d_outputs, d_output_nucs, d_output_rels)\r\n offset = offset + batch_size\r\n\r\n\r\ndef parse_and_eval(dataset, model):\r\n model.eval()\r\n parser = PartitionPtrParser(model)\r\n golds = list(filter(lambda d: d.root_relation(), chain(*dataset)))\r\n num_instances = len(golds)\r\n strips = []\r\n for paragraph in golds:\r\n edus = []\r\n for edu in paragraph.edus():\r\n edu_copy = EDU([TEXT(edu.text)])\r\n setattr(edu_copy, \"words\", edu.words)\r\n setattr(edu_copy, \"tags\", edu.tags)\r\n edus.append(edu_copy)\r\n strips.append(edus)\r\n parses = []\r\n for edus in strips:\r\n parse = parser.parse(edus)\r\n parses.append(parse)\r\n return num_instances, parse_eval(parses, golds)\r\n\r\n\r\ndef model_score(scores):\r\n eval_score = sum(score[2] for score in scores)\r\n return eval_score\r\n\r\n\r\ndef main(args):\r\n # set seed for reproducibility\r\n random.seed(args.seed)\r\n torch.manual_seed(args.seed)\r\n np.random.seed(args.seed)\r\n\r\n # load dataset\r\n cdtb = CDTB(args.data, \"TRAIN\", \"VALIDATE\", \"TEST\", ctb_dir=args.ctb_dir, preprocess=True, cache_dir=args.cache_dir)\r\n # build vocabulary\r\n word_vocab, pos_vocab, nuc_label, rel_label = build_vocab(cdtb.train)\r\n\r\n trainset = numericalize(cdtb.train, word_vocab, pos_vocab, nuc_label, rel_label)\r\n logging.info(\"num of instances trainset: %d\" % len(trainset))\r\n logging.info(\"args: %s\" % str(args))\r\n # build model\r\n model = PartitionPtr(hidden_size=args.hidden_size, dropout=args.dropout,\r\n word_vocab=word_vocab, pos_vocab=pos_vocab, nuc_label=nuc_label, rel_label=rel_label,\r\n pretrained=args.pretrained, w2v_size=args.w2v_size, w2v_freeze=args.w2v_freeze,\r\n pos_size=args.pos_size,\r\n split_mlp_size=args.split_mlp_size, nuc_mlp_size=args.nuc_mlp_size,\r\n rel_mlp_size=args.rel_mlp_size,\r\n use_gpu=args.use_gpu)\r\n if args.use_gpu:\r\n model.cuda()\r\n logging.info(\"model:\\n%s\" % str(model))\r\n\r\n # train and evaluate\r\n niter = 0\r\n log_splits_loss = 0.\r\n log_nucs_loss = 0.\r\n log_rels_loss = 0.\r\n log_loss = 0.\r\n optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.l2)\r\n writer = SummaryWriter(args.log_dir)\r\n logging.info(\"hint: run 'tensorboard --logdir %s' to observe training status\" % args.log_dir)\r\n best_model = None\r\n best_model_score = 0.\r\n for nepoch in range(1, args.epoch + 1):\r\n batch_iter = gen_batch_iter(trainset, args.batch_size, args.use_gpu)\r\n for nbatch, (e_inputs, d_inputs, grounds) in enumerate(batch_iter, start=1):\r\n niter += 1\r\n model.train()\r\n optimizer.zero_grad()\r\n splits_loss, nucs_loss, rels_loss = model.loss(e_inputs, d_inputs, grounds)\r\n loss = args.a_split_loss * splits_loss + args.a_nuclear_loss * nucs_loss + args.a_relation_loss * rels_loss\r\n loss.backward()\r\n optimizer.step()\r\n log_splits_loss += splits_loss.item()\r\n log_nucs_loss += nucs_loss.item()\r\n log_rels_loss += rels_loss.item()\r\n log_loss += loss.item()\r\n if niter % args.log_every == 0:\r\n logging.info(\"[iter %-6d]epoch: %-3d, batch %-5d,\"\r\n \"train splits loss:%.5f, nuclear loss %.5f, relation loss %.5f, loss %.5f\" %\r\n (niter, nepoch, nbatch, log_splits_loss, log_nucs_loss, log_rels_loss, log_loss))\r\n writer.add_scalar(\"train/split_loss\", log_splits_loss, niter)\r\n writer.add_scalar(\"train/nuclear_loss\", log_nucs_loss, niter)\r\n writer.add_scalar(\"train/relation_loss\", log_rels_loss, niter)\r\n writer.add_scalar(\"train/loss\", log_loss, niter)\r\n log_splits_loss = 0.\r\n log_nucs_loss = 0.\r\n log_rels_loss = 0.\r\n log_loss = 0.\r\n if niter % args.validate_every == 0:\r\n num_instances, validate_scores = parse_and_eval(cdtb.validate, model)\r\n logging.info(\"validation on %d instances\" % num_instances)\r\n logging.info(gen_parse_report(*validate_scores))\r\n writer.add_scalar(\"validate/span_f1\", validate_scores[0][2], niter)\r\n writer.add_scalar(\"validate/nuclear_f1\", validate_scores[1][2], niter)\r\n writer.add_scalar(\"validate/coarse_relation_f1\", validate_scores[2][2], niter)\r\n writer.add_scalar(\"validate/fine_relation_f1\", validate_scores[3][2], niter)\r\n new_model_score = model_score(validate_scores)\r\n if new_model_score > best_model_score:\r\n # test on testset with new best model\r\n best_model_score = new_model_score\r\n best_model = copy.deepcopy(model)\r\n logging.info(\"test on new best model\")\r\n num_instances, test_scores = parse_and_eval(cdtb.test, best_model)\r\n logging.info(\"test on %d instances\" % num_instances)\r\n logging.info(gen_parse_report(*test_scores))\r\n writer.add_scalar(\"test/span_f1\", test_scores[0][2], niter)\r\n writer.add_scalar(\"test/nuclear_f1\", test_scores[1][2], niter)\r\n writer.add_scalar(\"test/coarse_relation_f1\", test_scores[2][2], niter)\r\n writer.add_scalar(\"test/fine_relation_f1\", test_scores[3][2], niter)\r\n if best_model:\r\n # evaluation and save best model\r\n logging.info(\"final test result\")\r\n num_instances, test_scores = parse_and_eval(cdtb.test, best_model)\r\n logging.info(\"test on %d instances\" % num_instances)\r\n logging.info(gen_parse_report(*test_scores))\r\n logging.info(\"save best model to %s\" % args.model_save)\r\n with open(args.model_save, \"wb+\") as model_fd:\r\n torch.save(best_model, model_fd)\r\n writer.close()\r\n\r\n\r\nif __name__ == '__main__':\r\n logging.basicConfig(level=logging.INFO)\r\n arg_parser = argparse.ArgumentParser()\r\n\r\n # dataset parameters\r\n arg_parser.add_argument(\"--data\", default=\"data/CDTB\")\r\n arg_parser.add_argument(\"--ctb_dir\", default=\"data/CTB\")\r\n arg_parser.add_argument(\"--cache_dir\", default=\"data/cache\")\r\n\r\n # model parameters\r\n arg_parser.add_argument(\"-hidden_size\", default=512, type=int)\r\n arg_parser.add_argument(\"-dropout\", default=0.33, type=float)\r\n # w2v_group = arg_parser.add_mutually_exclusive_group(required=True)\r\n arg_parser.add_argument(\"-pretrained\", default=\"data/pretrained/sgns.renmin.word\")\r\n arg_parser.add_argument(\"-w2v_size\", type=int)\r\n arg_parser.add_argument(\"-pos_size\", default=30, type=int)\r\n arg_parser.add_argument(\"-split_mlp_size\", default=64, type=int)\r\n arg_parser.add_argument(\"-nuc_mlp_size\", default=32, type=int)\r\n arg_parser.add_argument(\"-rel_mlp_size\", default=128, type=int)\r\n arg_parser.add_argument(\"--w2v_freeze\", dest=\"w2v_freeze\", action=\"store_true\")\r\n arg_parser.set_defaults(w2v_freeze=True)\r\n\r\n # train parameters\r\n arg_parser.add_argument(\"-epoch\", default=20, type=int)\r\n arg_parser.add_argument(\"-batch_size\", default=64, type=int)\r\n arg_parser.add_argument(\"-lr\", default=0.001, type=float)\r\n arg_parser.add_argument(\"-l2\", default=0.0, type=float)\r\n arg_parser.add_argument(\"-log_every\", default=10, type=int)\r\n arg_parser.add_argument(\"-validate_every\", default=10, type=int)\r\n arg_parser.add_argument(\"-a_split_loss\", default=0.3, type=float)\r\n arg_parser.add_argument(\"-a_nuclear_loss\", default=1.0, type=float)\r\n arg_parser.add_argument(\"-a_relation_loss\", default=1.0, type=float)\r\n arg_parser.add_argument(\"-log_dir\", default=\"data/log\")\r\n arg_parser.add_argument(\"-model_save\", default=\"data/models/treebuilder.partptr.model\")\r\n arg_parser.add_argument(\"--seed\", default=21, type=int)\r\n arg_parser.add_argument(\"--use_gpu\", dest=\"use_gpu\", action=\"store_true\")\r\n arg_parser.set_defaults(use_gpu=True)\r\n\r\n main(arg_parser.parse_args())\r\n"
] | [
[
"numpy.zeros",
"numpy.random.seed",
"numpy.random.permutation",
"torch.save",
"torch.from_numpy",
"torch.manual_seed"
]
] |
LaudateCorpus1/coremltools | [
"777a4460d6823e5e91dea4fa3eacb0b11c7d5dfc",
"777a4460d6823e5e91dea4fa3eacb0b11c7d5dfc",
"777a4460d6823e5e91dea4fa3eacb0b11c7d5dfc"
] | [
"coremltools/converters/mil/mil/passes/conv_scale_fusion.py",
"coremltools/test/sklearn_tests/test_SVR.py",
"coremltools/converters/mil/experimental/passes/generic_linear_bias_fusion.py"
] | [
"# Copyright (c) 2021, Apple Inc. All rights reserved.\n#\n# Use of this source code is governed by a BSD-3-clause license that can be\n# found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause\n\nimport numpy as np\n\nfrom coremltools.converters.mil.mil.passes.pass_registry import register_pass\nfrom coremltools.converters.mil.mil.passes.graph_pass import AbstractGraphPass\nfrom coremltools.converters.mil.mil import Builder as mb\n\n\ndef _try_to_transform(conv_op, scale_op, block):\n\n # get the scale\n if scale_op.x.val is None and scale_op.y.val is None:\n return False\n scale_var = scale_op.x if scale_op.x.val is not None else scale_op.y\n scale = scale_var.val\n\n # for the scalar case, the scalar can be either\n # 1. a python int/float\n # 2. a 0d numpy array\n # 3. a 1d numpy array with shape (1,)\n\n is_scalar = True\n if isinstance(scale, np.ndarray):\n if scale.shape == ():\n scale = scale.tolist()\n elif scale.shape == (1) or scale.shape == (1,):\n scale = scale[0]\n else:\n is_scalar = False\n\n # get weight and bias and groups from conv layer\n if conv_op.weight.val is None:\n return False\n conv_weight = conv_op.weight.val\n conv_bias = conv_op.bias\n groups = conv_op.groups.val\n\n # get type of the conv layer\n is_deconv = conv_op.op_type == 'conv_transpose'\n is_conv_1d = len(conv_weight.shape) == 3\n\n # D_in denotes the spatial dimensions for conv kernel weight\n # for conv_transpose, conv_weight has shape [Cin, Cout / groups, *D_in]\n # for conv, conv_weight has shape [Cout, Cin / groups, *D_in]\n if is_deconv:\n Cout = conv_weight.shape[1] * groups\n Cin = conv_weight.shape[0]\n else:\n Cout = conv_weight.shape[0]\n Cin = conv_weight.shape[1] * groups\n\n # for the vector scale case, check if the shape is broacastable\n if not is_scalar:\n if not np.product(scale.shape) == Cout:\n return False\n if len(scale.shape) == len(conv_weight.shape):\n if not scale.shape[1] == Cout:\n return False\n elif len(scale.shape) == len(conv_weight.shape) - 1:\n if not scale.shape[0] == Cout:\n return False\n else:\n return False\n\n # transform the scale to 1./scale for the real_div case\n if scale_op.op_type == \"real_div\":\n scale = 1./scale\n\n # get the type of the conv weight\n conv_weight_type = conv_weight.dtype\n\n # create bias for conv if not exist\n if conv_bias is None:\n conv_bias = np.zeros(Cout)\n else:\n conv_bias = conv_bias.val\n conv_bias = conv_bias.astype(conv_weight_type)\n\n # get the original shape of weight and bias\n origin_weight_shape = conv_weight.shape\n origin_bias_shape = conv_bias.shape\n\n # update the weight/bias for conv layer\n if is_scalar:\n new_conv_bias = np.array(conv_bias * scale).astype(conv_weight_type)\n new_conv_weight = np.array(conv_weight * scale).astype(conv_weight_type)\n\n else:\n scale = np.reshape(scale, (Cout))\n new_conv_bias = np.array(conv_bias * scale).astype(conv_weight_type)\n new_conv_weight = []\n if is_deconv:\n conv_weight = np.transpose(conv_weight, [1, 0, 2] if is_conv_1d else [1, 0, 2, 3])\n conv_weight = np.reshape(conv_weight, [Cout, Cin // groups] + list(conv_weight.shape[2:]))\n\n for i in range(Cout):\n _conv_weight = conv_weight[i] * scale[i]\n new_conv_weight.append(_conv_weight)\n new_conv_weight = np.array(new_conv_weight).astype(conv_weight_type)\n\n if is_deconv:\n new_conv_weight = np.reshape(new_conv_weight, [Cout // groups, Cin] + list(new_conv_weight.shape[2:]))\n new_conv_weight = np.transpose(new_conv_weight, [1, 0, 2] if is_conv_1d else [1, 0, 2, 3])\n\n # make sure the updated weight and bias have the same shape as the original ones\n assert new_conv_weight.shape == origin_weight_shape, \"conv weight should have the same shape before and after the fuse_conv_scale pass.\"\n assert new_conv_bias.shape == origin_bias_shape, \"conv bias should have the same shape before and after the fuse_conv_scale pass.\"\n\n # create a new conv op with the new weight, bias value, copying rest of the attributes\n out_name = scale_op.outputs[0].name\n conv_kargs = {\"weight\": new_conv_weight, \"bias\": new_conv_bias, \"name\": out_name, \"before_op\": conv_op}\n\n for k, v in conv_op.inputs.items():\n if k in [\"weight\", \"bias\"]:\n continue\n conv_kargs[k] = v\n\n if is_deconv:\n x = mb.conv_transpose(**conv_kargs)\n else:\n x = mb.conv(**conv_kargs)\n\n scale_op.enclosing_block.replace_uses_of_var_after_op(\n anchor_op=scale_op, old_var=scale_op.outputs[0], new_var=x\n )\n # Remove all the ops at once\n block.remove_ops([conv_op, scale_op])\n return True\n\n@register_pass(namespace=\"common\")\nclass fuse_conv_scale(AbstractGraphPass):\n \"\"\"\n Fold mul/div into conv/conv_transpose by updating the weight/bias of the convolution layers.\n\n The scale const can be a single number (scalar) or a vector with a broacasable shape,\n for instance, if the output of the conv/deconv layer is (B, Cout, H, W),\n const of shape (Cout, 1, 1) and (1, Cout, 1, 1) are allowed.\n\n Given:\n %2 = conv(%1)\n ...\n %3 = mul(%2, constant) # where constant is the scale constant\n ...\n\n Result:\n %3 = conv(%1)\n ...\n\n \"\"\"\n def __init__(self):\n self.ops_to_skip = set()\n\n def set_ops_to_skip(self, prog):\n pass\n\n def _fuse_conv_scale_block(self, block):\n\n def _match_pattern(op):\n if op.op_type == \"conv\" or op.op_type == \"conv_transpose\":\n # abort fusion if op output is also a block output\n if op.outputs[0] in op.enclosing_block.outputs:\n return None\n # find batch_norm op\n child_ops = op.outputs[0].child_ops\n if len(child_ops) == 1:\n scale_op_candidate = list(child_ops)[0]\n if scale_op_candidate.op_type in [\"mul\", \"real_div\"]:\n return scale_op_candidate\n return None\n\n fusion_occurred = False\n for op in list(block.operations):\n for b in op.blocks:\n block_changed = True\n while block_changed:\n block_changed = self._fuse_conv_scale_block(b)\n if len(op.blocks) > 0:\n # This op can't be conv or conv_transpose\n continue\n\n scale_op = _match_pattern(op)\n\n if op in self.ops_to_skip or scale_op in self.ops_to_skip:\n continue\n\n if scale_op is not None:\n with block:\n fusion_occurred = _try_to_transform(op, scale_op, block)\n # has to break as the downstream iterator is affected.\n if fusion_occurred:\n return fusion_occurred\n return fusion_occurred\n\n def apply(self, prog):\n self.set_ops_to_skip(prog)\n for f in prog.functions.values():\n block_changed = True\n while block_changed:\n block_changed = self._fuse_conv_scale_block(f)\n",
"# Copyright (c) 2017, Apple Inc. All rights reserved.\n#\n# Use of this source code is governed by a BSD-3-clause license that can be\n# found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause\n\nimport pandas as pd\nimport numpy as np\nimport random\nimport tempfile\nimport unittest\nimport pytest\n\nfrom coremltools._deps import (\n _HAS_LIBSVM,\n MSG_LIBSVM_NOT_FOUND,\n _HAS_SKLEARN,\n MSG_SKLEARN_NOT_FOUND,\n)\nfrom coremltools.models.utils import evaluate_regressor, _macos_version, _is_macos\n\nif _HAS_LIBSVM:\n import svmutil\n import svm\n from coremltools.converters import libsvm\n\nif _HAS_SKLEARN:\n from sklearn.svm import SVR\n from sklearn.datasets import load_boston\n from coremltools.converters import sklearn as sklearn_converter\n from sklearn.preprocessing import OneHotEncoder\n\n\[email protected](not _HAS_SKLEARN, MSG_SKLEARN_NOT_FOUND)\nclass SvrScikitTest(unittest.TestCase):\n \"\"\"\n Unit test class for testing scikit-learn sklearn_converter.\n \"\"\"\n\n @classmethod\n def setUpClass(self):\n \"\"\"\n Set up the unit test by loading the dataset and training a model.\n \"\"\"\n if not _HAS_SKLEARN:\n return\n\n scikit_data = load_boston()\n scikit_model = SVR(kernel=\"linear\")\n scikit_model.fit(scikit_data[\"data\"], scikit_data[\"target\"])\n\n # Save the data and the model\n self.scikit_data = scikit_data\n self.scikit_model = scikit_model\n\n def test_conversion_bad_inputs(self):\n # Error on converting an untrained model\n with self.assertRaises(TypeError):\n model = SVR()\n spec = sklearn_converter.convert(model, \"data\", \"out\")\n\n # Check the expected class during covnersion.\n with self.assertRaises(TypeError):\n model = OneHotEncoder()\n spec = sklearn_converter.convert(model, \"data\", \"out\")\n\n @pytest.mark.slow\n def test_evaluation_stress_test(self):\n self._test_evaluation(allow_slow=True)\n\n def test_evaluation(self):\n self._test_evaluation(allow_slow=False)\n\n def _test_evaluation(self, allow_slow):\n \"\"\"\n Test that the same predictions are made\n \"\"\"\n\n # Generate some smallish (some kernels take too long on anything else) random data\n x, y = [], []\n for _ in range(50):\n cur_x1, cur_x2 = random.gauss(2, 3), random.gauss(-1, 2)\n x.append([cur_x1, cur_x2])\n y.append(1 + 2 * cur_x1 + 3 * cur_x2)\n\n input_names = [\"x1\", \"x2\"]\n df = pd.DataFrame(x, columns=input_names)\n\n # Parameters to test\n kernel_parameters = [\n {},\n {\"kernel\": \"rbf\", \"gamma\": 1.2},\n {\"kernel\": \"linear\"},\n {\"kernel\": \"poly\"},\n {\"kernel\": \"poly\", \"degree\": 2},\n {\"kernel\": \"poly\", \"gamma\": 0.75},\n {\"kernel\": \"poly\", \"degree\": 0, \"gamma\": 0.9, \"coef0\": 2},\n {\"kernel\": \"sigmoid\"},\n {\"kernel\": \"sigmoid\", \"gamma\": 1.3},\n {\"kernel\": \"sigmoid\", \"coef0\": 0.8},\n {\"kernel\": \"sigmoid\", \"coef0\": 0.8, \"gamma\": 0.5},\n ]\n non_kernel_parameters = [\n {},\n {\"C\": 1},\n {\"C\": 1.5, \"epsilon\": 0.5, \"shrinking\": True},\n {\"C\": 0.5, \"epsilon\": 1.5, \"shrinking\": False},\n ]\n\n # Test\n for param1 in non_kernel_parameters:\n for param2 in kernel_parameters:\n cur_params = param1.copy()\n cur_params.update(param2)\n print(\"cur_params=\" + str(cur_params))\n\n cur_model = SVR(**cur_params)\n cur_model.fit(x, y)\n df[\"prediction\"] = cur_model.predict(x)\n\n spec = sklearn_converter.convert(cur_model, input_names, \"target\")\n\n if _is_macos() and _macos_version() >= (10, 13):\n metrics = evaluate_regressor(spec, df)\n self.assertAlmostEqual(metrics[\"max_error\"], 0)\n\n if not allow_slow:\n break\n\n if not allow_slow:\n break\n\n\[email protected](not _HAS_LIBSVM, MSG_LIBSVM_NOT_FOUND)\[email protected](not _HAS_SKLEARN, MSG_SKLEARN_NOT_FOUND)\nclass EpsilonSVRLibSVMTest(unittest.TestCase):\n \"\"\"\n Unit test class for testing the libsvm sklearn converter.\n \"\"\"\n\n @classmethod\n def setUpClass(self):\n \"\"\"\n Set up the unit test by loading the dataset and training a model.\n \"\"\"\n if not _HAS_SKLEARN:\n return\n if not _HAS_LIBSVM:\n return\n\n scikit_data = load_boston()\n prob = svmutil.svm_problem(scikit_data[\"target\"], scikit_data[\"data\"].tolist())\n param = svmutil.svm_parameter()\n param.svm_type = svmutil.EPSILON_SVR\n param.kernel_type = svmutil.LINEAR\n param.eps = 1\n\n self.libsvm_model = svmutil.svm_train(prob, param)\n\n def test_input_names(self):\n data = load_boston()\n df = pd.DataFrame({\"input\": data[\"data\"].tolist()})\n df[\"input\"] = df[\"input\"].apply(np.array)\n\n # Default values\n spec = libsvm.convert(self.libsvm_model)\n if _is_macos() and _macos_version() >= (10, 13):\n (df[\"prediction\"], _, _) = svmutil.svm_predict(\n data[\"target\"], data[\"data\"].tolist(), self.libsvm_model\n )\n metrics = evaluate_regressor(spec, df)\n self.assertAlmostEqual(metrics[\"max_error\"], 0)\n\n # One extra parameters. This is legal/possible.\n num_inputs = len(data[\"data\"][0])\n spec = libsvm.convert(self.libsvm_model, input_length=num_inputs + 1)\n\n # Not enought input names.\n input_names = [\"this\", \"is\", \"not\", \"enought\", \"names\"]\n with self.assertRaises(ValueError):\n libsvm.convert(self.libsvm_model, input_names=input_names)\n with self.assertRaises(ValueError):\n libsvm.convert(self.libsvm_model, input_length=num_inputs - 1)\n\n def test_conversion_from_filesystem(self):\n libsvm_model_path = tempfile.mktemp(suffix=\"model.libsvm\")\n svmutil.svm_save_model(libsvm_model_path, self.libsvm_model)\n spec = libsvm.convert(\n libsvm_model_path, input_names=\"data\", target_name=\"target\"\n )\n\n def test_conversion_bad_inputs(self):\n # Check the expected class during covnersion.\n with self.assertRaises(TypeError):\n model = OneHotEncoder()\n spec = libsvm.convert(model, \"data\", \"out\")\n\n @pytest.mark.slow\n def test_evaluation_stress_test(self):\n self._test_evaluation(allow_slow=True)\n\n def test_evaluation(self):\n self._test_evaluation(allow_slow=False)\n\n def _test_evaluation(self, allow_slow):\n \"\"\"\n Test that the same predictions are made\n \"\"\"\n from svm import svm_parameter, svm_problem\n from svmutil import svm_train, svm_predict\n\n # Generate some smallish (poly kernels take too long on anything else) random data\n x, y = [], []\n for _ in range(50):\n cur_x1, cur_x2 = random.gauss(2, 3), random.gauss(-1, 2)\n x.append([cur_x1, cur_x2])\n y.append(1 + 2 * cur_x1 + 3 * cur_x2)\n\n input_names = [\"x1\", \"x2\"]\n df = pd.DataFrame(x, columns=input_names)\n prob = svm_problem(y, x)\n\n # Parameters\n base_param = \"-s 3\" # model type is epsilon SVR\n non_kernel_parameters = [\"\", \"-c 1.5 -p 0.5 -h 1\", \"-c 0.5 -p 0.5 -h 0\"]\n kernel_parameters = [\n \"\",\n \"-t 2 -g 1.2\", # rbf kernel\n \"-t 0\", # linear kernel\n \"-t 1\",\n \"-t 1 -d 2\",\n \"-t 1 -g 0.75\",\n \"-t 1 -d 0 -g 0.9 -r 2\", # poly kernel\n \"-t 3\",\n \"-t 3 -g 1.3\",\n \"-t 3 -r 0.8\",\n \"-t 3 -r 0.8 -g 0.5\", # sigmoid kernel\n ]\n\n for param1 in non_kernel_parameters:\n for param2 in kernel_parameters:\n param_str = \" \".join([base_param, param1, param2])\n print(param_str)\n param = svm_parameter(param_str)\n\n model = svm_train(prob, param)\n (df[\"prediction\"], _, _) = svm_predict(y, x, model)\n\n spec = libsvm.convert(\n model, input_names=input_names, target_name=\"target\"\n )\n\n if _is_macos() and _macos_version() >= (10, 13):\n metrics = evaluate_regressor(spec, df)\n self.assertAlmostEqual(metrics[\"max_error\"], 0)\n\n if not allow_slow:\n break\n\n if not allow_slow:\n break\n",
"# Copyright (c) 2021, Apple Inc. All rights reserved.\n#\n# Use of this source code is governed by a BSD-3-clause license that can be\n# found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause\n\nimport os\nimport numpy as np\n\nfrom coremltools.converters.mil import Builder as mb\nfrom coremltools.converters.mil.experimental.passes.generic_pass_infrastructure import register_generic_pass\nfrom coremltools.converters.mil.mil import get_new_symbol\n\nif os.getenv(\"ENABLE_EXPERIMENTAL_PASSES\") == \"1\":\n arbitrary_shape = (get_new_symbol(), get_new_symbol())\n np.random.seed()\n arbitrary_weight = np.random.rand(4, 3)\n arbitrary_bias = np.random.rand(4)\n\nif os.getenv(\"ENABLE_EXPERIMENTAL_PASSES\") == \"1\":\n @mb.program(input_specs=[mb.TensorSpec(shape=arbitrary_shape)])\n def pattern_add(x):\n \"\"\"\n Original:\n % 4 = linear(x= % 1, weight = % 2, bias = % 3) # %2 is a rank-2 const tensor (weight)\n # %3 is a rank-1 const tensor (bias)\n ...\n % 6 = add(x= % 4, y = % 5) # %5 is a const tensor with same shape as %3\n\n Result:\n % 8 = linear(x= % 1, weight = % 2, bias = % 7) # where %7 is a new const tensor with value\n # %7 = %3 + %6\n \"\"\"\n linear = mb.linear(x=x, weight=arbitrary_weight, bias=arbitrary_bias, name=\"linear\")\n add_or_sub = mb.add(x=linear, y=arbitrary_bias, name=\"add_or_sub\")\n return add_or_sub\n\nif os.getenv(\"ENABLE_EXPERIMENTAL_PASSES\") == \"1\":\n @mb.program(input_specs=[mb.TensorSpec(shape=arbitrary_shape)])\n def pattern_sub(x):\n \"\"\"\n Original:\n %4 = linear(x=%1, weight=%2, bias=%3) # %2 is a rank-2 const tensor (weight)\n # %3 is a rank-1 const tensor (bias)\n ...\n %6 = sub(x=%5, y=%4) # %5 is a const tensor with a broacasable shape with %3.\n i.e. if %3 has shape (Dout), %5 could be (1, Dout).\n\n Result:\n %9 = linear(x=%1, weight=%7, bias=%8) # where %7 is a new const tensor with value %7 = -%2\n # %8 = %5 - %3\n \"\"\"\n linear = mb.linear(x=x, weight=arbitrary_weight, bias=arbitrary_bias, name=\"linear\")\n add_or_sub = mb.sub(x=linear, y=arbitrary_bias, name=\"add_or_sub\")\n return add_or_sub\n\n\ndef var_constraints(pattern):\n passed = True\n passed = passed and pattern.add_or_sub.x.val is not None or pattern.add_or_sub.y.val is not None\n\n is_sub, is_first_input = _get_is_sub_and_is_first_input(pattern)\n linear_bias, bias, Dout = _get_linear_bias_bias_Dout(pattern, is_first_input)\n\n # check if the shape is broadcasable\n passed = passed and np.prod(linear_bias.shape) == np.prod(bias.shape)\n passed = passed and bias.shape[-1] == Dout\n return passed\n\n\ndef _get_is_sub_and_is_first_input(pattern):\n is_sub = pattern.add_or_sub.op_type == \"sub\"\n is_first_input = pattern.add_or_sub.x == pattern.linear.outputs[0]\n return is_sub, is_first_input\n\n\ndef _get_linear_bias_bias_Dout(pattern, is_first_input):\n linear_bias = pattern.linear.bias.val\n bias = pattern.add_or_sub.y.val if is_first_input else pattern.add_or_sub.x.val\n Dout = linear_bias.shape[0]\n return linear_bias, bias, Dout\n\n\ndef transform_pattern(pattern):\n is_sub, is_first_input = _get_is_sub_and_is_first_input(pattern)\n linear_bias, bias, Dout = _get_linear_bias_bias_Dout(pattern, is_first_input)\n bias = np.reshape(bias, (Dout,))\n\n if is_sub and is_first_input:\n bias = -bias\n if is_sub and not is_first_input:\n linear_bias = -linear_bias\n\n new_bias = linear_bias + bias\n\n # compute the new weight\n if is_sub and not is_first_input:\n new_weight = -pattern.linear.weight.val\n else:\n new_weight = pattern.linear.weight.val\n\n # create a new linear op with the new weight, bias value, copying rest of the attributes\n out_name = pattern.add_or_sub.outputs[0].name\n linear_kargs = {\"weight\": new_weight, \"bias\": new_bias, \"name\": out_name, \"before_op\": pattern.linear}\n\n linear_kargs.update({k: v for k, v in pattern.linear.inputs.items() if k not in [\"weight\", \"bias\"]})\n\n x = mb.linear(**linear_kargs)\n\n pattern.add_or_sub.enclosing_block.replace_uses_of_var_after_op(\n anchor_op=pattern.add_or_sub, old_var=pattern.add_or_sub.outputs[0], new_var=x\n )\n # Remove all the ops at once\n pattern.block.remove_ops(pattern.op_list())\n\n\nif os.getenv('ENABLE_EXPERIMENTAL_PASSES') == '1':\n register_generic_pass(\n ops_arrangement=pattern_add,\n var_constraints=var_constraints,\n transform_pattern=transform_pattern,\n pass_name=\"fuse_linear_bias\",\n namespace=\"common\",\n )\n\n register_generic_pass(\n ops_arrangement=pattern_sub,\n var_constraints=var_constraints,\n transform_pattern=transform_pattern,\n pass_name=\"fuse_linear_bias\",\n namespace=\"common\",\n )\n"
] | [
[
"numpy.product",
"numpy.array",
"numpy.reshape",
"numpy.zeros",
"numpy.transpose"
],
[
"pandas.DataFrame",
"sklearn.preprocessing.OneHotEncoder",
"sklearn.svm.SVR",
"sklearn.datasets.load_boston"
],
[
"numpy.random.seed",
"numpy.prod",
"numpy.random.rand",
"numpy.reshape"
]
] |
zeou1/maggot_models | [
"4e1b518c2981ab1ca9607099c3813e8429d94ca4",
"4e1b518c2981ab1ca9607099c3813e8429d94ca4",
"4e1b518c2981ab1ca9607099c3813e8429d94ca4",
"4e1b518c2981ab1ca9607099c3813e8429d94ca4",
"4e1b518c2981ab1ca9607099c3813e8429d94ca4",
"4e1b518c2981ab1ca9607099c3813e8429d94ca4",
"4e1b518c2981ab1ca9607099c3813e8429d94ca4",
"4e1b518c2981ab1ca9607099c3813e8429d94ca4",
"4e1b518c2981ab1ca9607099c3813e8429d94ca4"
] | [
"notebooks/39.1-BDP-unbiased-clustering.py",
"notebooks/103.0-BDP-cascade-invert.py",
"notebooks/71.0-BDP-pdiff.py",
"notebooks/120.4-BDP-silly-models.py",
"notebooks/64.2-BDP-threshold-investigations.py",
"notebooks/127.0-BDP-more-silly-model.py",
"data/process_scripts/process_maggot_brain_connectome_2020-04-23.py",
"src/visualization/stack_seaborn.py",
"models/runs/drosophila-6-rdpg-sbm/_sources/drosophila-6-rdpg-sbm_05c3491ee6aa302c433b6a825e3d3302.py"
] | [
"# %% [markdown]\n# # Imports\nimport json\nimport os\nimport warnings\nfrom operator import itemgetter\nfrom pathlib import Path\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nfrom joblib import Parallel, delayed\nfrom joblib.parallel import Parallel, delayed\nfrom sklearn.metrics import adjusted_rand_score\nimport networkx as nx\n\nfrom graspy.cluster import GaussianCluster, AutoGMMCluster\nfrom graspy.embed import AdjacencySpectralEmbed, OmnibusEmbed\nfrom graspy.models import DCSBMEstimator, SBMEstimator\nfrom graspy.plot import heatmap, pairplot\nfrom graspy.utils import binarize, cartprod, get_lcc, pass_to_ranks\nfrom src.data import load_everything\nfrom src.utils import export_skeleton_json, savefig\nfrom src.visualization import clustergram, palplot, sankey\nfrom src.hierarchy import signal_flow\n\nwarnings.simplefilter(\"ignore\", category=FutureWarning)\n\n\nFNAME = os.path.basename(__file__)[:-3]\nprint(FNAME)\n\n\n# %% [markdown]\n# # Parameters\nBRAIN_VERSION = \"2019-12-09\"\nGRAPH_TYPES = [\"Gad\", \"Gaa\", \"Gdd\", \"Gda\"]\nGRAPH_TYPE_LABELS = [r\"A $\\to$ D\", r\"A $\\to$ A\", r\"D $\\to$ D\", r\"D $\\to$ A\"]\nN_GRAPH_TYPES = len(GRAPH_TYPES)\n\nSAVEFIGS = True\nDEFAULT_FMT = \"png\"\nDEFUALT_DPI = 150\n\nSAVESKELS = False\n\nMIN_CLUSTERS = 8\nMAX_CLUSTERS = 8\nN_INIT = 50\nPTR = True\nONLY_RIGHT = True\n\nembed = \"LSE\"\ncluster = \"GMM\"\nn_components = 4\nif cluster == \"GMM\":\n gmm_params = {\"n_init\": N_INIT, \"covariance_type\": \"all\"}\nelif cluster == \"AutoGMM\":\n gmm_params = {\"max_agglom_size\": None}\n\nnp.random.seed(23409857)\n\n\ndef stashfig(name, **kws):\n if SAVEFIGS:\n savefig(name, foldername=FNAME, fmt=DEFAULT_FMT, dpi=DEFUALT_DPI, **kws)\n\n\ndef stashskel(name, ids, colors, palette=None, **kws):\n if SAVESKELS:\n return export_skeleton_json(\n name, ids, colors, palette=palette, foldername=FNAME, **kws\n )\n\n\ndef ase(adj, n_components):\n if PTR:\n adj = pass_to_ranks(adj)\n ase = AdjacencySpectralEmbed(n_components=n_components)\n latent = ase.fit_transform(adj)\n latent = np.concatenate(latent, axis=-1)\n return latent\n\n\ndef to_laplace(graph, form=\"DAD\", regularizer=None):\n r\"\"\"\n A function to convert graph adjacency matrix to graph laplacian. \n Currently supports I-DAD, DAD, and R-DAD laplacians, where D is the diagonal\n matrix of degrees of each node raised to the -1/2 power, I is the \n identity matrix, and A is the adjacency matrix.\n \n R-DAD is regularized laplacian: where :math:`D_t = D + regularizer*I`.\n Parameters\n ----------\n graph: object\n Either array-like, (n_vertices, n_vertices) numpy array,\n or an object of type networkx.Graph.\n form: {'I-DAD' (default), 'DAD', 'R-DAD'}, string, optional\n \n - 'I-DAD'\n Computes :math:`L = I - D*A*D`\n - 'DAD'\n Computes :math:`L = D*A*D`\n - 'R-DAD'\n Computes :math:`L = D_t*A*D_t` where :math:`D_t = D + regularizer*I`\n regularizer: int, float or None, optional (default=None)\n Constant to be added to the diagonal of degree matrix. If None, average \n node degree is added. If int or float, must be >= 0. Only used when \n ``form`` == 'R-DAD'.\n Returns\n -------\n L: numpy.ndarray\n 2D (n_vertices, n_vertices) array representing graph \n laplacian of specified form\n References\n ----------\n .. [1] Qin, Tai, and Karl Rohe. \"Regularized spectral clustering\n under the degree-corrected stochastic blockmodel.\" In Advances\n in Neural Information Processing Systems, pp. 3120-3128. 2013\n \"\"\"\n valid_inputs = [\"I-DAD\", \"DAD\", \"R-DAD\"]\n if form not in valid_inputs:\n raise TypeError(\"Unsuported Laplacian normalization\")\n\n A = graph\n\n in_degree = np.sum(A, axis=0)\n out_degree = np.sum(A, axis=1)\n\n # regularize laplacian with parameter\n # set to average degree\n if form == \"R-DAD\":\n if regularizer is None:\n regularizer = 1\n elif not isinstance(regularizer, (int, float)):\n raise TypeError(\n \"Regularizer must be a int or float, not {}\".format(type(regularizer))\n )\n elif regularizer < 0:\n raise ValueError(\"Regularizer must be greater than or equal to 0\")\n regularizer = regularizer * np.mean(out_degree)\n\n in_degree += regularizer\n out_degree += regularizer\n\n with np.errstate(divide=\"ignore\"):\n in_root = 1 / np.sqrt(in_degree) # this is 10x faster than ** -0.5\n out_root = 1 / np.sqrt(out_degree)\n\n in_root[np.isinf(in_root)] = 0\n out_root[np.isinf(out_root)] = 0\n\n in_root = np.diag(in_root) # just change to sparse diag for sparse support\n out_root = np.diag(out_root)\n\n if form == \"I-DAD\":\n L = np.diag(in_degree) - A\n L = in_root @ L @ in_root\n elif form == \"DAD\" or form == \"R-DAD\":\n L = out_root @ A @ in_root\n # return symmetrize(L, method=\"avg\") # sometimes machine prec. makes this necessary\n return L\n\n\ndef lse(adj, n_components, regularizer=None):\n if PTR:\n adj = pass_to_ranks(adj)\n lap = to_laplace(adj, form=\"R-DAD\")\n ase = AdjacencySpectralEmbed(n_components=n_components)\n latent = ase.fit_transform(lap)\n latent = np.concatenate(latent, axis=-1)\n return latent\n\n\ndef omni(adjs, n_components):\n if PTR:\n adjs = [pass_to_ranks(a) for a in adjs]\n omni = OmnibusEmbed(n_components=n_components // len(adjs))\n latent = omni.fit_transform(adjs)\n latent = np.concatenate(latent, axis=-1) # first is for in/out\n latent = np.concatenate(latent, axis=-1) # second is for concat. each graph\n return latent\n\n\ndef ase_concatenate(adjs, n_components):\n if PTR:\n adjs = [pass_to_ranks(a) for a in adjs]\n ase = AdjacencySpectralEmbed(n_components=n_components // len(adjs))\n graph_latents = []\n for a in adjs:\n latent = ase.fit_transform(a)\n latent = np.concatenate(latent, axis=-1)\n graph_latents.append(latent)\n latent = np.concatenate(graph_latents, axis=-1)\n return latent\n\n\ndef sub_ari(known_inds, true_labels, pred_labels):\n true_known_labels = true_labels[known_inds]\n pred_known_labels = pred_labels[known_inds]\n ari = adjusted_rand_score(true_known_labels, pred_known_labels)\n return ari\n\n\n# Set up plotting constants\nplt.style.use(\"seaborn-white\")\nsns.set_palette(\"deep\")\nsns.set_context(\"talk\", font_scale=1)\n\n\n# %% [markdown]\n# # Load the data\n\n\nadj, class_labels, side_labels, skeleton_labels = load_everything(\n \"Gad\",\n version=BRAIN_VERSION,\n return_keys=[\"Merge Class\", \"Hemisphere\"],\n return_ids=True,\n)\n\n\n# select the right hemisphere\nif ONLY_RIGHT:\n side = \"right hemisphere\"\n right_inds = np.where(side_labels == \"R\")[0]\n adj = adj[np.ix_(right_inds, right_inds)]\n class_labels = class_labels[right_inds]\n skeleton_labels = skeleton_labels[right_inds]\nelse:\n side = \"full brain\"\n\n# sort by number of synapses\ndegrees = adj.sum(axis=0) + adj.sum(axis=1)\nsort_inds = np.argsort(degrees)[::-1]\nadj = adj[np.ix_(sort_inds, sort_inds)]\nclass_labels = class_labels[sort_inds]\nskeleton_labels = skeleton_labels[sort_inds]\n\n# remove disconnected nodes\nadj, lcc_inds = get_lcc(adj, return_inds=True)\nclass_labels = class_labels[lcc_inds]\nskeleton_labels = skeleton_labels[lcc_inds]\n\n# remove pendants\ndegrees = np.count_nonzero(adj, axis=0) + np.count_nonzero(adj, axis=1)\nnot_pendant_mask = degrees != 1\nnot_pendant_inds = np.array(range(len(degrees)))[not_pendant_mask]\nadj = adj[np.ix_(not_pendant_inds, not_pendant_inds)]\nclass_labels = class_labels[not_pendant_inds]\nskeleton_labels = skeleton_labels[not_pendant_inds]\n\n# plot degree sequence\nd_sort = np.argsort(degrees)[::-1]\ndegrees = degrees[d_sort]\nplt.figure(figsize=(10, 5))\nsns.scatterplot(x=range(len(degrees)), y=degrees, s=30, linewidth=0)\n\nknown_inds = np.where(class_labels != \"Unk\")[0]\n\n\n# %% [markdown]\n# # Run clustering using LSE on the sum graph\n\nn_verts = adj.shape[0]\n\n\nlatent = lse(adj, n_components, regularizer=None)\npairplot(latent, labels=class_labels, title=embed)\n\nk_list = list(range(MIN_CLUSTERS, MAX_CLUSTERS + 1))\nn_runs = len(k_list)\nout_dicts = []\n\nbin_adj = binarize(adj)\n\nlast_pred_labels = np.zeros(n_verts)\n\nif cluster == \"GMM\":\n ClusterModel = GaussianCluster\nelif cluster == \"AutoGMM\":\n ClusterModel = AutoGMMCluster\n\nfor k in k_list:\n run_name = f\"k = {k}, {cluster}, {embed}, {side} (A to D), PTR, raw\"\n print(run_name)\n print()\n\n # Do clustering\n # TODO: make this autogmm instead\n gmm = ClusterModel(min_components=k, max_components=k, **gmm_params)\n gmm.fit(latent)\n pred_labels = gmm.predict(latent)\n\n # Score unsupervised metrics\n base_dict = {\n \"K\": k,\n \"Cluster\": cluster,\n \"Embed\": embed,\n \"Method\": f\"{cluster} o {embed}\",\n }\n\n # GMM likelihood\n score = gmm.model_.score(latent)\n temp_dict = base_dict.copy()\n temp_dict[\"Metric\"] = \"GMM likelihood\"\n temp_dict[\"Score\"] = score\n out_dicts.append(temp_dict)\n\n # GMM BIC\n score = gmm.model_.bic(latent)\n temp_dict = base_dict.copy()\n temp_dict[\"Metric\"] = \"GMM BIC\"\n temp_dict[\"Score\"] = score\n out_dicts.append(temp_dict)\n\n # SBM likelihood\n sbm = SBMEstimator(directed=True, loops=False)\n sbm.fit(bin_adj, y=pred_labels)\n score = sbm.score(bin_adj)\n temp_dict = base_dict.copy()\n temp_dict[\"Metric\"] = \"SBM likelihood\"\n temp_dict[\"Score\"] = score\n out_dicts.append(temp_dict)\n\n # DCSBM likelihood\n dcsbm = DCSBMEstimator(directed=True, loops=False)\n dcsbm.fit(bin_adj, y=pred_labels)\n score = dcsbm.score(bin_adj)\n temp_dict = base_dict.copy()\n temp_dict[\"Metric\"] = \"DCSBM likelihood\"\n temp_dict[\"Score\"] = score\n out_dicts.append(temp_dict)\n\n # ARI of the subset with labels\n score = sub_ari(known_inds, class_labels, pred_labels)\n temp_dict = base_dict.copy()\n temp_dict[\"Metric\"] = \"Simple ARI\"\n temp_dict[\"Score\"] = score\n out_dicts.append(temp_dict)\n\n # ARI vs K - 1\n score = adjusted_rand_score(last_pred_labels, pred_labels)\n temp_dict = base_dict.copy()\n temp_dict[\"Metric\"] = \"K-1 ARI\"\n temp_dict[\"Score\"] = score\n out_dicts.append(temp_dict)\n last_pred_labels = pred_labels\n\n save_name = f\"k{k}-{cluster}-{embed}-right-ad-PTR-raw\"\n\n # Plot embedding\n # pairplot(latent, labels=pred_labels, title=run_name)\n # stashfig(\"latent-\" + save_name)\n\n # Plot everything else\n clustergram(adj, class_labels, pred_labels)\n stashfig(\"clustergram-\" + save_name)\n\n # New plot\n # - Compute signal flow\n # - Get the centroid of each cluster and project to 1d\n # - Alternatively, just take the first dimension\n # - For each cluster plot as a node\n\n # output skeletons\n if SAVESKELS:\n _, colormap, pal = stashskel(\n save_name, skeleton_labels, pred_labels, palette=\"viridis\", multiout=True\n )\n\n palplot(k, cmap=\"viridis\")\n stashfig(\"palplot-\" + save_name)\n\n # save dict colormapping\n filename = (\n Path(\"./maggot_models/notebooks/outs\")\n / Path(FNAME)\n / str(\"colormap-\" + save_name + \".json\")\n )\n with open(filename, \"w\") as fout:\n json.dump(colormap, fout)\n\n stashskel(\n save_name, skeleton_labels, pred_labels, palette=\"viridis\", multiout=False\n )\n\n# %% [markdown]\n# # Plot results of unsupervised metrics\n\nresult_df = pd.DataFrame(out_dicts)\nfg = sns.FacetGrid(result_df, col=\"Metric\", col_wrap=3, sharey=False, height=4)\nfg.map(sns.lineplot, \"K\", \"Score\")\nstashfig(f\"metrics-{cluster}-{embed}-right-ad-PTR-raw\")\n\n\n# Modifications i need to make to the above\n# - Increase the height of the sankey diagram overall\n# - Look into color maps that could be better\n# - Color the cluster labels by what gets written to the JSON\n# - Plot the clusters as nodes in a small network\n\n# %% [markdown]\n# # try graph flow\n\n\nnode_signal_flow = signal_flow(adj)\nmean_sf = np.zeros(k)\nfor i in np.unique(pred_labels):\n inds = np.where(pred_labels == i)[0]\n mean_sf[i] = np.mean(node_signal_flow[inds])\n\ncluster_mean_latent = gmm.model_.means_[:, 0]\nblock_probs = SBMEstimator().fit(bin_adj, y=pred_labels).block_p_\nblock_prob_df = pd.DataFrame(data=block_probs, index=range(k), columns=range(k))\nblock_g = nx.from_pandas_adjacency(block_prob_df, create_using=nx.DiGraph)\nplt.figure(figsize=(10, 10))\n# don't ever let em tell you you're too pythonic\npos = dict(zip(range(k), zip(cluster_mean_latent, mean_sf)))\n# nx.draw_networkx_nodes(block_g, pos=pos)\nlabels = nx.get_edge_attributes(block_g, \"weight\")\n# nx.draw_networkx_edge_labels(block_g, pos, edge_labels=labels)\nfrom matplotlib.cm import ScalarMappable\nimport matplotlib as mpl\n\nnorm = mpl.colors.LogNorm(vmin=0.01, vmax=0.1)\n\nsm = ScalarMappable(cmap=\"Reds\", norm=norm)\ncmap = sm.to_rgba(np.array(list(labels.values())) + 0.01)\nnx.draw_networkx(\n block_g,\n pos,\n edge_cmap=\"Reds\",\n edge_color=cmap,\n connectionstyle=\"arc3,rad=0.2\",\n width=1.5,\n)\n\n# %% [markdown]\n# # signal flow marginals\n\nsignal_flow_marginal(adj, pred_labels)\n\n# %% [markdown]\n# #\n\n\ndef signal_flow_marginal(adj, labels, col_wrap=5, palette=\"tab20\"):\n sf = signal_flow(adj)\n uni_labels = np.unique(labels)\n medians = []\n for i in uni_labels:\n inds = np.where(labels == i)[0]\n medians.append(np.median(sf[inds]))\n sort_inds = np.argsort(medians)[::-1]\n col_order = uni_labels[sort_inds]\n plot_df = pd.DataFrame()\n plot_df[\"Signal flow\"] = sf\n plot_df[\"Class\"] = labels\n fg = sns.FacetGrid(\n plot_df,\n col=\"Class\",\n aspect=1.5,\n palette=palette,\n col_order=col_order,\n sharey=False,\n col_wrap=col_wrap,\n xlim=(-3, 3),\n )\n fg = fg.map(sns.distplot, \"Signal flow\") # bins=np.linspace(-2.2, 2.2))\n fg.set(yticks=[], yticklabels=[])\n plt.tight_layout()\n return fg\n\n\nsignal_flow_marginal(adj, class_labels)\nstashfig(\"known-class-sf-marginal\")\n\n# tomorrow\n# DEFINITELY\n# run with unsupervised metrics from k=2-50\n\n# IF TIME\n# run hgmm\n",
"# %% [markdown]\n# #\nimport itertools\nimport os\nimport time\nfrom itertools import chain\n\nimport colorcet as cc\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport networkx as nx\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nfrom anytree import LevelOrderGroupIter, Node, RenderTree\nfrom joblib import Parallel, delayed\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\nfrom sklearn.decomposition import PCA\n\nfrom graspy.plot import heatmap, pairplot\nfrom src.data import load_metagraph\nfrom src.graph import MetaGraph, preprocess\nfrom src.io import savecsv, savefig, saveskels\nfrom src.traverse import (\n cascades_from_node,\n generate_cascade_tree,\n generate_random_walks,\n path_to_visits,\n to_markov_matrix,\n to_path_graph,\n)\nfrom src.visualization import (\n CLASS_COLOR_DICT,\n barplot_text,\n draw_networkx_nice,\n draw_separators,\n matrixplot,\n remove_shared_ax,\n remove_spines,\n screeplot,\n sort_meta,\n stacked_barplot,\n)\n\nFNAME = os.path.basename(__file__)[:-3]\nprint(FNAME)\n\n\ndef stashfig(name, **kws):\n savefig(name, foldername=FNAME, save_on=True, **kws)\n\n\ndef stashcsv(df, name, **kws):\n savecsv(df, name, foldername=FNAME, save_on=True, **kws)\n\n\n#%% Load and preprocess the data\n\nVERSION = \"2020-03-09\"\nprint(f\"Using version {VERSION}\")\n\nplot_examples = False\nplot_embed = False\nplot_full_mat = False\ngraph_type = \"Gad\"\nthreshold = 0\nweight = \"weight\"\nmg = load_metagraph(graph_type, VERSION)\nmg = preprocess(\n mg,\n threshold=threshold,\n sym_threshold=False,\n remove_pdiff=True,\n binarize=False,\n weight=weight,\n)\nprint(f\"Preprocessed graph {graph_type} with threshold={threshold}, weight={weight}\")\n\n# TODO update this with the mixed groups\n# TODO make these functional for selecting proper paths\n\nout_classes = [\n \"O_dSEZ\",\n \"O_dSEZ;CN\",\n \"O_dSEZ;LHN\",\n \"O_dVNC\",\n \"O_dVNC;O_RG\",\n \"O_dVNC;CN\",\n \"O_RG\",\n \"O_dUnk\",\n \"O_RG-IPC\",\n \"O_RG-ITP\",\n \"O_RG-CA-LP\",\n]\nfrom_groups = [\n (\"sens-ORN\",),\n (\"sens-photoRh5\", \"sens-photoRh6\"),\n (\"sens-MN\",),\n (\"sens-thermo\",),\n (\"sens-vtd\",),\n (\"sens-AN\",),\n]\nfrom_group_names = [\"Odor\", \"Photo\", \"MN\", \"Temp\", \"VTD\", \"AN\"]\n\nout_groups = [\n (\"motor-mAN\", \"motormVAN\", \"motor-mPaN\"),\n (\"O_dSEZ\", \"O_dVNC;O_dSEZ\", \"O_dSEZ;CN\", \"LHN;O_dSEZ\"),\n (\"O_dVNC\", \"O_dVNC;CN\", \"O_RG;O_dVNC\", \"O_dVNC;O_dSEZ\"),\n (\"O_RG\", \"O_RG-IPC\", \"O_RG-ITP\", \"O_RG-CA-LP\", \"O_RG;O_dVNC\"),\n (\"O_dUnk\",),\n]\nout_group_names = [\"Motor\", \"SEZ\", \"VNC\", \"RG\", \"dUnk\"]\n\n\nfrom_classes = list(chain.from_iterable(from_groups)) # make this a flat list\nout_classes = list(chain.from_iterable(out_groups))\n\nclass_key = \"Merge Class\"\n\nadj = nx.to_numpy_array(mg.g, weight=weight, nodelist=mg.meta.index.values)\nn_verts = len(adj)\nmeta = mg.meta.copy()\ng = mg.g.copy()\nmeta[\"idx\"] = range(len(meta))\n\nfrom_inds = meta[meta[class_key].isin(from_classes)][\"idx\"].values\nout_inds = meta[meta[class_key].isin(out_classes)][\"idx\"].values\nind_map = dict(zip(meta.index, meta[\"idx\"]))\ng = nx.relabel_nodes(g, ind_map, copy=True)\nout_ind_map = dict(zip(out_inds, range(len(out_inds))))\n\n# %% [markdown]\n# # Use a method to generate visits\n\npath_type = \"cascade\"\nif path_type == \"cascade\":\n p = 0.01\n not_probs = (\n 1 - p\n ) ** adj # probability of none of the synapses causing postsynaptic\n probs = 1 - not_probs # probability of ANY of the synapses firing onto next\nelif path_type == \"fancy-cascade\":\n alpha = 0.5\n flat = np.full(adj.shape, alpha)\n deg = meta[\"dendrite_input\"].values\n deg[deg == 0] = 1\n flat = flat / deg[None, :]\n not_probs = np.power((1 - flat), adj)\n probs = 1 - not_probs\n\n#%%\nseed = 8888\nmax_depth = 10\nn_bins = 10\nn_sims = 100\nmethod = \"tree\"\nnormalize_n_source = False\n\n\nbasename = f\"-{graph_type}-t{threshold}-pt{path_type}-b{n_bins}-n{n_sims}-m{method}\"\nbasename += f\"-norm{normalize_n_source}\"\nbasename += f\"-plus-inverted\"\n\n\nnp.random.seed(seed)\nif method == \"tree\":\n seeds = np.random.choice(int(1e8), size=len(from_inds), replace=False)\n outs = Parallel(n_jobs=1, verbose=10)(\n delayed(cascades_from_node)(\n fi, probs, out_inds, max_depth, n_sims, seed, n_bins, method\n )\n for fi, seed in zip(from_inds, seeds)\n )\nelif method == \"path\":\n outs = []\n for start_ind in from_inds:\n temp_hist = cascades_from_node(\n start_ind, probs, out_inds, max_depth, n_sims, seed, n_bins, method\n )\n outs.append(temp_hist)\nfrom_hist_mat = np.concatenate(outs, axis=-1)\n\n###\n# invert\nif method == \"tree\":\n seeds = np.random.choice(int(1e8), size=len(out_inds), replace=False)\n outs = Parallel(n_jobs=1, verbose=10)(\n delayed(cascades_from_node)(\n fi, probs.T, from_inds, max_depth, n_sims, seed, n_bins, method\n )\n for fi, seed in zip(out_inds, seeds)\n )\nelif method == \"path\":\n outs = []\n for start_ind in from_inds:\n temp_hist = cascades_from_node(\n start_ind, probs.T, out_inds, max_depth, n_sims, seed, n_bins, method\n )\n outs.append(temp_hist)\nout_hist_mat = np.concatenate(outs, axis=-1)\n\n\n# generate_cascade_paths(start_ind, probs, 1, stop_inds=out_inds, max_depth=10)\n# %% [markdown]\n# # Sort metadata\nfull_hist_mat = np.concatenate((from_hist_mat, out_hist_mat), axis=1)\nhist_mat = full_hist_mat\n# row metadata\nids = pd.Series(index=meta[\"idx\"], data=meta.index, name=\"id\")\nto_class = ids.map(meta[\"Merge Class\"])\nto_class.name = \"to_class\"\nrow_df = pd.concat([ids, to_class], axis=1)\n\n# col metadata\norders = pd.Series(data=len(from_inds) * list(range(n_bins)), name=\"order\")\nfrom_idx = pd.Series(data=np.repeat(from_inds, n_bins), name=\"idx\")\nfrom_ids = from_idx.map(ids)\nfrom_ids.name = \"id\"\nfrom_class = from_ids.map(meta[\"Merge Class\"])\nfrom_class.name = \"class\"\nfrom_col_df = pd.concat([orders, from_idx, from_ids, from_class], axis=1)\n\norders = pd.Series(data=len(out_inds) * list(range(n_bins)), name=\"order\")\nout_idx = pd.Series(data=np.repeat(out_inds, n_bins), name=\"idx\")\nout_ids = out_idx.map(ids)\nout_ids.name = \"id\"\nout_class = out_ids.map(meta[\"Merge Class\"])\nout_class.name = \"class\"\nout_col_df = pd.concat([orders, out_idx, out_ids, out_class], axis=1)\ncol_df = pd.concat([from_col_df, out_col_df], axis=0, ignore_index=True)\n# %% [markdown]\n# #\nlog_mat = np.log10(hist_mat + 1)\nif plot_full_mat:\n shape = log_mat.shape\n figsize = (10, 20)\n fig, ax = plt.subplots(1, 1, figsize=figsize)\n matrixplot(\n log_mat,\n ax=ax,\n col_meta=col_df,\n col_sort_class=[\"from_class\"],\n row_meta=row_df,\n row_sort_class=[\"to_class\"],\n plot_type=\"scattermap\",\n sizes=(0.5, 0.5),\n tick_rot=45,\n )\n stashfig(\"log-full-scatter\" + basename)\n\n fig, ax = plt.subplots(1, 1, figsize=figsize)\n matrixplot(\n log_mat,\n ax=ax,\n col_meta=col_df,\n col_sort_class=[\"from_class\"],\n row_colors=CLASS_COLOR_DICT,\n row_meta=row_df,\n row_sort_class=[\"to_class\"],\n plot_type=\"heatmap\",\n sizes=(0.5, 0.5),\n tick_rot=45,\n )\n stashfig(\"log-full-heat\" + basename)\n\n# %% [markdown]\n# # Screeplots\n\nif plot_embed:\n screeplot(hist_mat.astype(float), title=\"Raw hist mat (full)\")\n stashfig(\"scree-raw-mat\" + basename)\n screeplot(log_mat, title=\"Log hist mat (full)\")\n stashfig(\"scree-log-mat\" + basename)\n\n# %% [markdown]\n# # Pairplots\nif plot_embed:\n pca = PCA(n_components=6)\n embed = pca.fit_transform(log_mat)\n loadings = pca.components_.T\n pg = pairplot(\n embed,\n labels=to_class.values,\n palette=CLASS_COLOR_DICT,\n height=5,\n title=\"Node response embedding (log)\",\n )\n pg._legend.remove()\n stashfig(\"node-pca-log\" + basename)\n pg = pairplot(\n loadings,\n labels=from_class.values,\n height=5,\n title=\"Source class embedding (log)\",\n )\n stashfig(\"source-pca-log\" + basename)\n\n pca = PCA(n_components=6)\n embed = pca.fit_transform(hist_mat.astype(float))\n loadings = pca.components_.T\n pg = pairplot(\n embed,\n labels=to_class.values,\n palette=CLASS_COLOR_DICT,\n height=5,\n title=\"Node response embedding (raw)\",\n )\n pg._legend.remove()\n stashfig(\"node-pca-log\" + basename)\n pg = pairplot(\n loadings,\n labels=from_class.values,\n height=5,\n title=\"Source class embedding (raw)\",\n )\n stashfig(\"source-pca-log\" + basename)\n\n# %% [markdown]\n# # Collapse that matrix\nhist_mat = full_hist_mat\ncollapsed_hist = []\ncollapsed_col_df = []\ngroups = from_groups + out_groups\nnames = from_group_names + out_group_names\nfor fg, fg_name in zip(groups, names):\n from_df = col_df[col_df[\"class\"].isin(fg)]\n n_in_group = len(from_df)\n for order in from_df[\"order\"].unique():\n inds = from_df[from_df[\"order\"] == order].index\n col = hist_mat[:, inds].sum(axis=1)\n if normalize_n_source:\n col = col.astype(float)\n col /= n_in_group\n collapsed_hist.append(col)\n row = {\"order\": order, \"class\": fg_name}\n collapsed_col_df.append(row)\n\n\ncollapsed_col_df = pd.DataFrame(collapsed_col_df)\ncollapsed_hist = np.array(collapsed_hist).T\nlog_collapsed_hist = np.log10(collapsed_hist + 1)\n\n# %% [markdown]\n# #\nif plot_embed:\n pca = PCA(n_components=6)\n embed = pca.fit_transform(log_collapsed_hist)\n loadings = pca.components_.T\n pg = pairplot(\n embed,\n labels=to_class.values,\n palette=CLASS_COLOR_DICT,\n height=5,\n title=\"Collapsed node response embedding (log)\",\n )\n pg._legend.remove()\n stashfig(\"coll-node-pca-log\" + basename)\n pg = pairplot(\n loadings,\n labels=collapsed_col_df[\"from_class\"].values,\n height=5,\n title=\"Collapsed source class embedding (log)\",\n )\n stashfig(\"coll-source-pca-log\" + basename)\n\n pca = PCA(n_components=6)\n embed = pca.fit_transform(collapsed_hist.astype(float))\n loadings = pca.components_.T\n pg = pairplot(\n embed,\n labels=to_class.values,\n palette=CLASS_COLOR_DICT,\n height=5,\n title=\"Collapsed node response embedding (raw)\",\n )\n pg._legend.remove()\n stashfig(\"coll-node-pca-log\" + basename)\n pg = pairplot(\n loadings,\n labels=collapsed_col_df[\"from_class\"].values,\n height=5,\n title=\"Collapsed source class embedding (raw)\",\n )\n stashfig(\"coll-source-pca-log\" + basename)\n\n# %% [markdown]\n# # Compute mean visit over all sources, for plotting\ndef mean_visit(row):\n n_groups = len(row) // n_bins\n s = 0\n for i in range(n_groups):\n group = row[i * n_bins : (i + 1) * n_bins]\n for j, val in enumerate(group):\n s += j * val\n s /= row.sum()\n return s\n\n\nvisits = []\nfor r in collapsed_hist:\n mv = mean_visit(r)\n visits.append(mv)\nvisits = np.array(visits)\nvisits[np.isnan(visits)] = n_bins + 1\nrow_df[\"visit_order\"] = visits\nmean_visit_order = row_df.groupby([\"to_class\"])[\"visit_order\"].mean()\nrow_df[\"group_visit_order\"] = row_df[\"to_class\"].map(mean_visit_order)\nrow_df[\"n_visit\"] = collapsed_hist.sum(axis=1)\n# %% [markdown]\n# #\nfig, ax = plt.subplots(1, 1, figsize=(15, 15))\nsns.set_context(\"talk\", font_scale=0.8)\ngridline_kws = dict(color=\"grey\", linestyle=\"--\", alpha=0.7, linewidth=0.3)\nmatrixplot(\n log_collapsed_hist,\n ax=ax,\n col_meta=collapsed_col_df,\n col_sort_class=[\"class\"],\n row_meta=row_df,\n row_sort_class=[\"to_class\"],\n row_colors=CLASS_COLOR_DICT,\n row_class_order=\"group_visit_order\",\n row_item_order=[\"visit_order\"],\n plot_type=\"heatmap\",\n tick_rot=0,\n row_ticks=False,\n gridline_kws=gridline_kws,\n)\nstashfig(\"collapsed-log-heat\" + basename)\n\n# %% [markdown]\n# #\nsns.set_context(\"talk\", font_scale=1)\ngridline_kws = dict(color=\"grey\", linestyle=\"--\", alpha=0.7, linewidth=0.3)\n\nfig, ax = plt.subplots(1, 1, figsize=(25, 15))\nax, divider, top_cax, left_cax = matrixplot(\n log_collapsed_hist.T,\n ax=ax,\n row_meta=collapsed_col_df,\n row_sort_class=[\"class\"],\n col_meta=row_df,\n col_sort_class=[\"to_class\"],\n col_colors=CLASS_COLOR_DICT,\n col_class_order=\"group_visit_order\",\n col_item_order=[\"visit_order\"],\n plot_type=\"heatmap\",\n tick_rot=45,\n col_ticks=False,\n gridline_kws=gridline_kws,\n)\ncax = divider.append_axes(\"right\", size=\"1%\", pad=0.02, sharey=ax)\nremove_shared_ax(cax)\nsns.heatmap(\n collapsed_col_df[\"order\"][:, None], ax=cax, cbar=False, cmap=\"RdBu\", center=0\n)\ncax.set_xticks([])\ncax.set_yticks([])\ncax.set_ylabel(r\"Hops $\\to$\", rotation=-90, ha=\"center\", va=\"center\", labelpad=20)\ncax.yaxis.set_label_position(\"right\")\ntop_cax.set_yticks([0.5])\ntop_cax.set_yticklabels([\"Class\"], va=\"center\")\nax.set_xlabel(\"Neuron\")\nax.set_ylabel(\"Source class\")\nstashfig(\"collapsed-log-heat-transpose\" + basename, dpi=200)\n\nfig, ax = plt.subplots(1, 1, figsize=(25, 15))\nax, divider, top_cax, left_cax = matrixplot(\n log_collapsed_hist.T,\n ax=ax,\n row_meta=collapsed_col_df,\n row_sort_class=[\"class\"],\n col_meta=row_df,\n col_sort_class=[\"to_class\"],\n col_colors=CLASS_COLOR_DICT,\n col_class_order=\"group_visit_order\",\n col_item_order=[\"visit_order\"],\n plot_type=\"heatmap\",\n tick_rot=45,\n col_ticks=True,\n gridline_kws=gridline_kws,\n)\ncax = divider.append_axes(\"right\", size=\"1%\", pad=0.02, sharey=ax)\nremove_shared_ax(cax)\nsns.heatmap(\n collapsed_col_df[\"order\"][:, None], ax=cax, cbar=False, cmap=\"RdBu\", center=0\n)\ncax.set_xticks([])\ncax.set_yticks([])\ncax.set_ylabel(r\"Hops $\\to$\", rotation=-90, ha=\"center\", va=\"center\", labelpad=20)\ncax.yaxis.set_label_position(\"right\")\ntop_cax.set_yticks([0.5])\ntop_cax.set_yticklabels([\"Class\"], va=\"center\")\nax.set_xlabel(\"Neuron\")\nax.set_ylabel(\"Source class\")\nstashfig(\"collapsed-log-heat-transpose-labeled\" + basename, dpi=200)\n\n# %% [markdown]\n# # clustermap the matrix\n\n\nsns.set_context(\"talk\", font_scale=1)\nlinkage = \"average\"\nmetric = \"euclidean\"\ncolors = np.vectorize(CLASS_COLOR_DICT.get)(row_df[\"to_class\"])\n\nperm_inds, sort_collapsed_col_df = sort_meta(\n collapsed_col_df, sort_class=[\"from_class\"]\n)\nsort_log_collapsed_hist = log_collapsed_hist[:, perm_inds]\n\n\ncg = sns.clustermap(\n data=sort_log_collapsed_hist.T,\n col_cluster=True,\n row_cluster=False,\n col_colors=colors,\n cmap=\"RdBu_r\",\n center=0,\n cbar_pos=None,\n method=linkage,\n metric=metric,\n)\nax = cg.ax_heatmap\ndraw_separators(\n ax,\n ax_type=\"y\",\n sort_meta=sort_collapsed_col_df,\n sort_class=[\"from_class\"],\n tick_rot=0,\n)\nax.xaxis.set_ticks([])\n# ax.set_ylabel(r\"Visits over time $\\to$\")\nax.set_xlabel(\"Neuron\")\nax.yaxis.tick_left()\n# ax.set_yticklabels(ax.get_yticklabels(), ha=\"left\")\nstashfig(\"collapsed-log-clustermap\" + basename)\n# stashfig(\"collapsed-log-clustermap\" + basename, fmt=\"pdf\")\n\n\n# %% [markdown]\n# # Do some plotting for illustration only\n\n\nif plot_examples:\n sns.set_context(\"talk\")\n sns.set_palette(\"Set1\")\n examples = [742, 605, 743, 2282, 596, 2367, 1690, 2313]\n for target_ind in examples:\n row = collapsed_hist[target_ind, :]\n perm_inds, sort_col_df = sort_meta(collapsed_col_df, sort_class=[\"from_class\"])\n sort_row = row[perm_inds]\n\n fig, ax = plt.subplots(1, 1)\n xs = np.arange(len(sort_row)) + 0.5\n divider = make_axes_locatable(ax)\n bot_cax = divider.append_axes(\"bottom\", size=\"3%\", pad=0.02, sharex=ax)\n remove_shared_ax(bot_cax)\n\n ax.bar(x=xs, height=sort_row, width=0.8)\n draw_separators(\n ax, sort_meta=sort_col_df, sort_class=[\"from_class\"], tick_rot=0\n )\n ax.set_xlim(0, len(xs))\n ax.set_ylabel(\"# hits @ time\")\n\n sns.heatmap(\n collapsed_col_df[\"order\"][None, :],\n ax=bot_cax,\n cbar=False,\n cmap=\"RdBu\",\n center=0,\n )\n bot_cax.set_xticks([])\n bot_cax.set_yticks([])\n bot_cax.set_xlabel(r\"Hops $\\to$\", x=0.1, ha=\"left\", labelpad=-22)\n bot_cax.set_xticks([20.5, 24.5, 28.5])\n bot_cax.set_xticklabels([1, 5, 9], rotation=0)\n\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"top\"].set_visible(False)\n target_skid = meta.iloc[target_ind, :].name\n ax.set_title(\n f\"Response for cell {target_skid} ({meta[meta['idx'] == target_ind]['Merge Class'].values[0]})\"\n )\n\n stashfig(f\"{target_skid}-response-hist\" + basename)\n\n",
"#%%\nfrom src.data import load_metagraph\nimport seaborn as sns\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n\nmg = load_metagraph(\"G\", \"2020-01-21\")\n\nis_pdiff = np.where(mg[\"is_pdiff\"])[0]\nmg = mg.reindex(is_pdiff)\ndegree_df = mg.calculate_degrees()\nplt.figure()\nmelt_degree = pd.melt(\n degree_df.reset_index(),\n id_vars=[\"ID\"],\n value_vars=[\"In degree\", \"Out degree\", \"Total degree\"],\n value_name=\"Degree\",\n)\nsns.stripplot(y=\"Degree\", data=melt_degree, x=\"variable\", jitter=0.45)\n\nplt.figure()\nmelt_syns = pd.melt(\n degree_df.reset_index(),\n id_vars=[\"ID\"],\n value_vars=[\"In edgesum\", \"Out edgesum\", \"Total edgesum\"],\n value_name=\"Synapses\",\n)\nsns.stripplot(y=\"Synapses\", data=melt_syns, x=\"variable\", jitter=0.45)\n",
"# %% [markdown]\n# # THE MIND OF A MAGGOT\n\n# %% [markdown]\n# ## Imports\nimport os\nimport time\n\nimport colorcet as cc\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport matplotlib.transforms as transforms\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nfrom scipy.linalg import orthogonal_procrustes\nfrom scipy.optimize import linear_sum_assignment\nfrom sklearn.metrics import adjusted_rand_score\nfrom tqdm import tqdm\n\nfrom graspy.cluster import GaussianCluster\nfrom graspy.embed import AdjacencySpectralEmbed\nfrom graspy.models import DCSBMEstimator, RDPGEstimator, SBMEstimator\nfrom graspy.plot import heatmap, pairplot\nfrom graspy.simulations import rdpg\nfrom graspy.utils import binarize, pass_to_ranks\nfrom src.data import load_metagraph\nfrom src.graph import preprocess\nfrom src.hierarchy import signal_flow\nfrom src.io import savefig\nfrom src.visualization import (\n CLASS_COLOR_DICT,\n barplot_text,\n gridmap,\n matrixplot,\n stacked_barplot,\n adjplot,\n)\nfrom sklearn.utils.testing import ignore_warnings\nfrom sklearn.exceptions import ConvergenceWarning\nimport warnings\n\nwarnings.filterwarnings(action=\"ignore\", category=ConvergenceWarning)\n\nCLUSTER_SPLIT = \"best\"\n\nFNAME = os.path.basename(__file__)[:-3]\nprint(FNAME)\n\nrc_dict = {\n \"axes.spines.right\": False,\n \"axes.spines.top\": False,\n \"axes.formatter.limits\": (-3, 3),\n \"figure.figsize\": (6, 3),\n \"figure.dpi\": 100,\n}\nfor key, val in rc_dict.items():\n mpl.rcParams[key] = val\ncontext = sns.plotting_context(context=\"talk\", font_scale=1, rc=rc_dict)\nsns.set_context(context)\n\nnp.random.seed(8888)\n\n\ndef stashfig(name, **kws):\n savefig(name, foldername=FNAME, save_on=True, **kws)\n\n\ndef get_paired_inds(meta):\n pair_meta = meta[meta[\"Pair\"].isin(meta.index)]\n pair_group_size = pair_meta.groupby(\"Pair ID\").size()\n remove_pairs = pair_group_size[pair_group_size == 1].index\n pair_meta = pair_meta[~pair_meta[\"Pair ID\"].isin(remove_pairs)]\n assert pair_meta.groupby(\"Pair ID\").size().min() == 2\n pair_meta.sort_values([\"Pair ID\", \"hemisphere\"], inplace=True)\n lp_inds = pair_meta[pair_meta[\"hemisphere\"] == \"L\"][\"inds\"]\n rp_inds = pair_meta[pair_meta[\"hemisphere\"] == \"R\"][\"inds\"]\n assert (\n meta.iloc[lp_inds][\"Pair ID\"].values == meta.iloc[rp_inds][\"Pair ID\"].values\n ).all()\n return lp_inds, rp_inds\n\n\n# TODO broken in some cases, switched to `compute_pairedness_bipartite`\ndef compute_pairedness(partition, left_pair_inds, right_pair_inds, plot=False):\n uni_labels, inv = np.unique(partition, return_inverse=True)\n train_int_mat = np.zeros((len(uni_labels), len(uni_labels)))\n for i, ul in enumerate(uni_labels):\n c1_mask = inv == i\n for j, ul in enumerate(uni_labels):\n c2_mask = inv == j\n # number of times a thing in cluster 1 has a pair also in cluster 2\n pairs_in_other = np.logical_and(\n c1_mask[left_pair_inds], c2_mask[right_pair_inds]\n ).sum()\n train_int_mat[i, j] = pairs_in_other\n\n row_ind, col_ind = linear_sum_assignment(train_int_mat, maximize=True)\n train_pairedness = np.trace(train_int_mat[np.ix_(row_ind, col_ind)]) / np.sum(\n train_int_mat\n ) # TODO double check that this is right\n\n if plot:\n fig, axs = plt.subplots(1, 2, figsize=(20, 10))\n sns.heatmap(\n train_int_mat, square=True, ax=axs[0], cbar=False, cmap=\"RdBu_r\", center=0\n )\n int_df = pd.DataFrame(data=train_int_mat, index=uni_labels, columns=uni_labels)\n int_df = int_df.reindex(index=uni_labels[row_ind])\n int_df = int_df.reindex(columns=uni_labels[col_ind])\n sns.heatmap(int_df, square=True, ax=axs[1], cbar=False, cmap=\"RdBu_r\", center=0)\n\n return train_pairedness, row_ind, col_ind\n\n\ndef compute_pairedness_bipartite(left_labels, right_labels):\n left_uni_labels, left_inv = np.unique(left_labels, return_inverse=True)\n right_uni_labels, right_inv = np.unique(right_labels, return_inverse=True)\n train_int_mat = np.zeros((len(left_uni_labels), len(right_uni_labels)))\n for i, ul in enumerate(left_uni_labels):\n c1_mask = left_inv == i\n for j, ul in enumerate(right_uni_labels):\n c2_mask = right_inv == j\n # number of times a thing in cluster 1 has a pair also in cluster 2\n pairs_in_other = np.logical_and(c1_mask, c2_mask).sum()\n train_int_mat[i, j] = pairs_in_other\n\n row_ind, col_ind = linear_sum_assignment(train_int_mat, maximize=True)\n train_pairedness = np.trace(train_int_mat[np.ix_(row_ind, col_ind)]) / np.sum(\n train_int_mat\n ) # TODO double check that this is right\n return train_pairedness, row_ind, col_ind\n\n\ndef fit_and_score(X_train, X_test, k, **kws):\n gc = GaussianCluster(min_components=k, max_components=k, **kws)\n gc.fit(X_train)\n model = gc.model_\n train_bic = model.bic(X_train)\n train_lik = model.score(X_train)\n test_bic = model.bic(X_test)\n test_lik = model.score(X_test)\n bic = model.bic(np.concatenate((X_train, X_test), axis=0))\n res = {\n \"train_bic\": -train_bic,\n \"train_lik\": train_lik,\n \"test_bic\": -test_bic,\n \"test_lik\": test_lik,\n \"bic\": -bic,\n \"lik\": train_lik + test_lik,\n \"k\": k,\n \"model\": gc.model_,\n }\n return res, model\n\n\ndef crossval_cluster(\n embed,\n left_inds,\n right_inds,\n min_clusters=2,\n max_clusters=15,\n n_init=25,\n left_pair_inds=None,\n right_pair_inds=None,\n):\n left_embed = embed[left_inds]\n right_embed = embed[right_inds]\n print(\"Running left/right clustering with cross-validation\\n\")\n currtime = time.time()\n rows = []\n for k in tqdm(range(min_clusters, max_clusters)):\n # TODO add option for AutoGMM as well, might as well check\n for i in range(n_init):\n left_row, left_gc = fit_and_score(left_embed, right_embed, k)\n left_row[\"train\"] = \"left\"\n right_row, right_gc = fit_and_score(right_embed, left_embed, k)\n right_row[\"train\"] = \"right\"\n\n # pairedness computation, if available\n if left_pair_inds is not None and right_pair_inds is not None:\n # TODO double check this is right\n pred_left = left_gc.predict(embed[left_pair_inds])\n pred_right = right_gc.predict(embed[right_pair_inds])\n pness, _, _ = compute_pairedness_bipartite(pred_left, pred_right)\n left_row[\"pairedness\"] = pness\n right_row[\"pairedness\"] = pness\n\n ari = adjusted_rand_score(pred_left, pred_right)\n left_row[\"ARI\"] = ari\n right_row[\"ARI\"] = ari\n\n rows.append(left_row)\n rows.append(right_row)\n\n results = pd.DataFrame(rows)\n print(f\"{time.time() - currtime} elapsed\")\n return results\n\n\ndef plot_crossval_cluster(results):\n fig, axs = plt.subplots(3, 1, figsize=(10, 10), sharex=True)\n\n ax = axs[0]\n sns.lineplot(data=results, x=\"k\", y=\"test_lik\", hue=\"train\", ax=ax, legend=False)\n ax.lines[0].set_linestyle(\"--\")\n ax.lines[1].set_linestyle(\"--\")\n sns.lineplot(data=results, x=\"k\", y=\"train_lik\", hue=\"train\", ax=ax, legend=False)\n ax.set_ylabel(\"Log likelihood\")\n ax.yaxis.set_major_locator(mpl.ticker.MaxNLocator(nbins=3, min_n_ticks=3))\n\n ax = axs[1]\n sns.lineplot(data=results, x=\"k\", y=\"test_bic\", hue=\"train\", ax=ax, legend=\"full\")\n ax.lines[0].set_linestyle(\"--\")\n ax.lines[1].set_linestyle(\"--\")\n sns.lineplot(data=results, x=\"k\", y=\"train_bic\", hue=\"train\", ax=ax, legend=\"full\")\n ax.set_ylabel(\"-BIC\")\n ax.yaxis.set_major_locator(mpl.ticker.MaxNLocator(nbins=3, min_n_ticks=3))\n\n leg = ax.legend()\n leg.set_title(\"Train side\")\n leg.texts[0].set_text(\"Test contra\")\n leg.set_bbox_to_anchor((1, 1.8))\n lines = leg.get_lines()\n lines[0].set_linestyle(\"--\")\n lines[1].set_linestyle(\"--\")\n lines[2].set_linestyle(\"--\")\n leg.texts[3].set_text(\"Test ipsi\")\n\n ax = axs[2]\n sns.lineplot(\n data=results,\n x=\"k\",\n y=\"pairedness\",\n ax=ax,\n legend=\"full\",\n color=\"purple\",\n label=\"Pairedness\",\n )\n sns.lineplot(\n data=results, x=\"k\", y=\"ARI\", ax=ax, legend=\"full\", color=\"green\", label=\"ARI\"\n )\n ax.set_ylabel(\"Pair score\")\n leg = ax.legend().remove()\n ax.legend(bbox_to_anchor=(1, 1), loc=\"upper left\")\n # leg.loc = 2\n # leg.set_bbox_to_anchor((1, 1))\n\n # ax.yaxis.set_major_locator(mpl.ticker.MaxNLocator(nbins=3, min_n_ticks=3))\n # trans = transforms.blended_transform_factory(ax.transAxes, ax.transAxes)\n # ax.text(0.8, 0.8, \"Pairedness\", color=\"purple\", transform=trans)\n # ax.text(0.8, 0.6, \"ARI\", color=\"green\", transform=trans)\n return fig, axs\n\n\ndef make_ellipses(gmm, ax, i, j, colors, alpha=0.5, equal=False, **kws):\n inds = [j, i]\n for n, color in enumerate(colors):\n if gmm.covariance_type == \"full\":\n covariances = gmm.covariances_[n][np.ix_(inds, inds)]\n elif gmm.covariance_type == \"tied\":\n covariances = gmm.covariances_[np.ix_(inds, inds)]\n elif gmm.covariance_type == \"diag\":\n covariances = np.diag(gmm.covariances_[n][inds])\n elif gmm.covariance_type == \"spherical\":\n covariances = np.eye(gmm.means_.shape[1]) * gmm.covariances_[n]\n v, w = np.linalg.eigh(covariances)\n u = w[0] / np.linalg.norm(w[0])\n angle = np.arctan2(u[1], u[0])\n angle = 180 * angle / np.pi # convert to degrees\n v = 2.0 * np.sqrt(2.0) * np.sqrt(v)\n ell = mpl.patches.Ellipse(\n gmm.means_[n, inds], v[0], v[1], 180 + angle, color=color, **kws\n )\n ell.set_clip_box(ax.bbox)\n ell.set_alpha(alpha)\n ax.add_artist(ell)\n if equal:\n ax.set_aspect(\"equal\", \"datalim\")\n\n\ndef plot_cluster_pairs(\n X, left_inds, right_inds, left_model, right_model, labels, colors=None, equal=True\n):\n k = left_model.n_components\n n_dims = X.shape[1]\n\n if colors is None:\n colors = sns.color_palette(\"tab10\", n_colors=k, desat=0.7)\n\n fig, axs = plt.subplots(\n n_dims, n_dims, sharex=False, sharey=False, figsize=(20, 20)\n )\n data = pd.DataFrame(data=X)\n data[\"label\"] = labels #\n pred = composite_predict(\n X, left_inds, right_inds, left_model, right_model, relabel=False\n )\n data[\"pred\"] = pred\n\n for i in range(n_dims):\n for j in range(n_dims):\n ax = axs[i, j]\n ax.axis(\"off\")\n if i < j:\n sns.scatterplot(\n data=data,\n x=j,\n y=i,\n ax=ax,\n alpha=0.5,\n linewidth=0,\n s=5,\n legend=False,\n hue=\"label\",\n palette=CLASS_COLOR_DICT,\n )\n make_ellipses(left_model, ax, i, j, colors, fill=False, equal=equal)\n if i > j:\n sns.scatterplot(\n data=data,\n x=j,\n y=i,\n ax=ax,\n alpha=0.7,\n linewidth=0,\n s=5,\n legend=False,\n hue=\"pred\",\n palette=colors,\n )\n make_ellipses(left_model, ax, i, j, colors, fill=True, equal=equal)\n\n plt.tight_layout()\n return fig, axs\n\n\ndef composite_predict(X, left_inds, right_inds, left_model, right_model, relabel=False):\n # TODO add option to boost the right numbers\n X_left = X[left_inds]\n X_right = X[right_inds]\n pred_left = left_model.predict(X_left)\n pred_right = right_model.predict(X_right)\n if relabel:\n leftify = np.vectorize(lambda x: str(x) + \"L\")\n rightify = np.vectorize(lambda x: str(x) + \"R\")\n pred_left = leftify(pred_left)\n pred_right = rightify(pred_right)\n dtype = pred_left.dtype\n pred = np.empty(len(X), dtype=dtype)\n pred[left_inds] = pred_left\n pred[right_inds] = pred_right\n return pred\n\n\ndef reindex_model(gmm, perm_inds):\n gmm.weights_ = gmm.weights_[perm_inds]\n gmm.means_ = gmm.means_[perm_inds]\n if gmm.covariance_type != \"tied\":\n gmm.covariances_ = gmm.covariances_[perm_inds]\n gmm.precisions_ = gmm.precisions_[perm_inds]\n gmm.precisions_cholesky_ = gmm.precisions_cholesky_[perm_inds]\n return gmm\n\n\ndef plot_metrics(results, plot_all=True):\n plot_results = results.copy()\n plot_results[\"k\"] += np.random.normal(size=len(plot_results), scale=0.1)\n\n fig, axs = plt.subplots(3, 3, figsize=(20, 10), sharex=True)\n\n def miniplotter(var, ax):\n if plot_all:\n sns.scatterplot(\n data=plot_results,\n x=\"k\",\n y=var,\n hue=\"train\",\n ax=ax,\n s=8,\n linewidth=0,\n alpha=0.5,\n )\n best_inds = results.groupby([\"k\"])[var].idxmax()\n best_results = results.loc[best_inds].copy()\n sns.lineplot(\n data=best_results, x=\"k\", y=var, ax=ax, color=\"purple\", label=\"max\"\n )\n mean_results = results.groupby([\"k\"]).mean()\n mean_results.reset_index(inplace=True)\n sns.lineplot(\n data=mean_results, x=\"k\", y=var, ax=ax, color=\"green\", label=\"mean\"\n )\n ax.get_legend().remove()\n\n plot_vars = [\n \"train_lik\",\n \"test_lik\",\n \"lik\",\n \"train_bic\",\n \"test_bic\",\n \"bic\",\n \"ARI\",\n \"pairedness\",\n ]\n axs = axs.T.ravel()\n\n for pv, ax in zip(plot_vars, axs):\n miniplotter(pv, ax)\n\n axs[2].xaxis.set_major_locator(mpl.ticker.MultipleLocator(2))\n axs[-2].tick_params(labelbottom=True)\n axs[-2].set_xlabel(\"k\")\n\n handles, labels = axs[-2].get_legend_handles_labels()\n axs[-1].legend(handles, labels, loc=\"upper left\")\n axs[-1].axis(\"off\")\n\n return fig, axs\n\n\n# %% [markdown]\n# ## Load data\n# In this case we are working with `G`, the directed graph formed by summing the edge\n# weights of the 4 different graph types. Preprocessing here includes removing\n# partially differentiated cells, and cutting out the lowest 5th percentile of nodes in\n# terms of their number of incident synapses. 5th percentile ~= 12 synapses. After this,\n# the largest connected component is used.\n\nmg = load_metagraph(\"G\", version=\"2020-04-01\")\nmg = preprocess(\n mg,\n threshold=0,\n sym_threshold=False,\n remove_pdiff=True,\n binarize=False,\n weight=\"weight\",\n)\nmeta = mg.meta\n\n# plot where we are cutting out nodes based on degree\ndegrees = mg.calculate_degrees()\nfig, ax = plt.subplots(1, 1, figsize=(5, 2.5))\nsns.distplot(np.log10(degrees[\"Total edgesum\"]), ax=ax)\nq = np.quantile(degrees[\"Total edgesum\"], 0.05)\nax.axvline(np.log10(q), linestyle=\"--\", color=\"r\")\nax.set_xlabel(\"log10(total synapses)\")\n\n# remove low degree neurons\nidx = meta[degrees[\"Total edgesum\"] > q].index\nmg = mg.reindex(idx, use_ids=True)\n\n# remove center neurons # FIXME\nidx = mg.meta[mg.meta[\"hemisphere\"].isin([\"L\", \"R\"])].index\nmg = mg.reindex(idx, use_ids=True)\n\nmg = mg.make_lcc()\nmg.calculate_degrees(inplace=True)\nmeta = mg.meta\n\nadj = mg.adj\nadj = pass_to_ranks(adj)\nmeta[\"inds\"] = range(len(meta))\n\nleft_inds = meta[meta[\"left\"]][\"inds\"]\nright_inds = meta[meta[\"right\"]][\"inds\"]\nlp_inds, rp_inds = get_paired_inds(meta)\n\n\n# %% [markdown]\n# ## Embed\n# Here the embedding is ASE, with PTR and DiagAug, the number of embedding dimensions\n# is for now set to ZG2 (4 + 4). Using the known pairs as \"seeds\", the left embedding\n# is matched to the right using procrustes.\nase = AdjacencySpectralEmbed(n_components=None, n_elbows=2)\nembed = ase.fit_transform(adj)\nn_components = embed[0].shape[1] # use all of ZG2\nX = np.concatenate((embed[0][:, :n_components], embed[1][:, :n_components]), axis=-1)\nR, _ = orthogonal_procrustes(X[lp_inds], X[rp_inds])\n\nif CLUSTER_SPLIT == \"best\":\n X[left_inds] = X[left_inds] @ R\n\n# %% [markdown]\n# ## Clustering\n# Clustering is performed using Gaussian mixture modeling. At each candidate value of k,\n# 50 models are trained on the left embedding, 50 models are trained on the right\n# embedding (choosing the best covariance structure based on BIC on the train set).\nresults = crossval_cluster(\n X,\n left_inds,\n right_inds,\n left_pair_inds=lp_inds,\n right_pair_inds=rp_inds,\n max_clusters=15,\n n_init=50,\n)\n# best_inds = results.groupby([\"k\", \"train\"])[\"test_bic\"].idxmax()\n# best_results = results.loc[best_inds].copy()\n# plot_crossval_cluster(best_results)\n# stashfig(f\"cross-val-n_components={n_components}\")\n\n# %% [markdown]\n# ## Evaluating Clustering\n# Of the 100 models we fit as described above, we now evaluate them on a variety of\n# metrics:\n# - likelihood of the data the model was trained on (\"train_lik\")\n# - likelihood of the held out (other hemisphere) data (\"test_lik\")\n# - likelihood of all of the data (\"lik\", = \"train_lik\" + \"test_lik\")\n# - BIC using the data the model was trained on (\"train_bic\")\n# - BIC using the held out (other hemisphere) data (\"test_bic\")\n# - BIC using all of the data (\"bic\")\n# - ARI for pairs. Given the prediction of the model on the left data and the right\n# data, using known pairs to define a correspondence between (some) nodes, what is\n# the ARI(left_prediction, right_prediciton) for the given model\n# - Pairedness, like the above but simply the raw fraction of pairs that end up in\n# corresponding L/R clusters. Very related to ARI but not normalized.\n\nplot_metrics(results)\nstashfig(f\"cluster-metrics-n_components={n_components}\")\n\n\n# %% [markdown]\n# ## Choose a model\n# A few things are clear from the above. One is that the likelihood on the train set\n# continues to go up as `k` increases, but plateaus and then drops on the test set around\n# k = 6 - 8. This is even slightly more clear when looking at the BIC plots, where the\n# only difference is the added penalty for complexity. Based on this, I would say that\n# the best k at this scale is around 6-8; however, we still need to pick a single metric\n# to give us the *best* model to proceed. I'm not sure whether it makes more sense to use\n# likelihood or bic here, or, to use performance on the test set or performance on all\n# of the data. Here we will proceed with k=7, and choose the model with the best BIC on\n# all of the data.\n\nk = 6\nmetric = \"bic\"\nbasename = f\"-metric={metric}-k={k}-n_components={n_components}\"\nbasetitle = f\"Metric={metric}, k={k}, n_components={n_components}\"\n\nind = results[results[\"k\"] == k][metric].idxmax()\n\nprint(f\"Choosing model at k={k} based on best {metric}.\\n\")\nprint(f\"ARI: {results.loc[ind, 'ARI']}\")\nprint(f\"Pairedness: {results.loc[ind, 'pairedness']}\\n\")\n\nmodel = results.loc[ind, \"model\"]\nleft_model = model\nright_model = model\n\npred = composite_predict(\n X, left_inds, right_inds, left_model, right_model, relabel=False\n)\npred_side = composite_predict(\n X, left_inds, right_inds, left_model, right_model, relabel=True\n)\n\nax = stacked_barplot(\n pred_side, meta[\"merge_class\"].values, color_dict=CLASS_COLOR_DICT, legend_ncol=6\n)\nax.set_title(basetitle)\nstashfig(f\"barplot\" + basename)\n\n\nfig, ax = plot_cluster_pairs(\n X, left_inds, right_inds, left_model, right_model, meta[\"merge_class\"].values\n)\nfig.suptitle(basetitle, y=1)\n\nstashfig(f\"pairs\" + basename)\n\n\nsf = signal_flow(adj)\nmeta[\"signal_flow\"] = -sf\nmeta[\"pred\"] = pred\nmeta[\"pred_side\"] = pred_side\nmeta[\"group_signal_flow\"] = meta[\"pred\"].map(meta.groupby(\"pred\")[\"signal_flow\"].mean())\nfig, ax = plt.subplots(1, 1, figsize=(20, 20))\nadjplot(\n adj,\n ax=ax,\n meta=meta,\n sort_class=\"pred_side\",\n class_order=\"group_signal_flow\",\n colors=\"merge_class\",\n palette=CLASS_COLOR_DICT,\n item_order=[\"merge_class\", \"signal_flow\"],\n plot_type=\"scattermap\",\n sizes=(0.5, 1),\n)\nfig.suptitle(basetitle, y=0.94)\nstashfig(f\"adj-sf\" + basename)\n\nmeta[\"te\"] = -meta[\"Total edgesum\"]\nfig, ax = plt.subplots(1, 1, figsize=(20, 20))\nadjplot(\n adj,\n ax=ax,\n meta=meta,\n sort_class=\"pred_side\",\n class_order=\"group_signal_flow\",\n colors=\"merge_class\",\n palette=CLASS_COLOR_DICT,\n item_order=[\"merge_class\", \"te\"],\n plot_type=\"scattermap\",\n sizes=(0.5, 1),\n)\nfig.suptitle(basetitle, y=0.94)\nstashfig(f\"adj-te\" + basename)\n\nmeta[\"rand\"] = np.random.uniform(size=len(meta))\nfig, ax = plt.subplots(1, 1, figsize=(20, 20))\nadjplot(\n adj,\n ax=ax,\n meta=meta,\n sort_class=\"pred_side\",\n class_order=\"group_signal_flow\",\n colors=\"merge_class\",\n palette=CLASS_COLOR_DICT,\n item_order=\"rand\",\n plot_type=\"scattermap\",\n sizes=(0.5, 1),\n)\nfig.suptitle(basetitle, y=0.94)\nstashfig(f\"adj-rand\" + basename)\n\n# %% [markdown]\n# ## SUBCLUSTER\n\nnp.random.seed(8888)\n\nuni_labels, inv = np.unique(pred, return_inverse=True)\nall_sub_results = []\nsub_data = []\n\nreembed = False\n\nfor label in uni_labels:\n print(label)\n print()\n label_mask = pred == label\n sub_meta = meta[label_mask].copy()\n sub_meta[\"inds\"] = range(len(sub_meta))\n sub_left_inds = sub_meta[sub_meta[\"left\"]][\"inds\"].values\n sub_right_inds = sub_meta[sub_meta[\"right\"]][\"inds\"].values\n sub_lp_inds, sub_rp_inds = get_paired_inds(sub_meta)\n sub_adj = adj[np.ix_(label_mask, label_mask)]\n\n if reembed:\n ase = AdjacencySpectralEmbed()\n # TODO look into PTR at this level as well\n sub_embed = ase.fit_transform(sub_adj)\n sub_X = np.concatenate(sub_embed, axis=1)\n sub_R, _ = orthogonal_procrustes(sub_X[sub_lp_inds], sub_X[sub_rp_inds])\n sub_X[sub_left_inds] = sub_X[sub_left_inds] @ sub_R\n else:\n sub_X = X[label_mask].copy()\n sub_R = R\n\n var_dict = {\n \"meta\": sub_meta,\n \"left_inds\": sub_left_inds,\n \"right_inds\": sub_right_inds,\n \"left_pair_inds\": sub_lp_inds,\n \"right_pair_inds\": sub_rp_inds,\n \"X\": sub_X,\n \"adj\": sub_adj,\n }\n\n sub_data.append(var_dict)\n\n sub_results = crossval_cluster(\n sub_X,\n sub_left_inds,\n sub_right_inds,\n left_pair_inds=sub_lp_inds,\n right_pair_inds=sub_rp_inds,\n max_clusters=10,\n min_clusters=1,\n n_init=50,\n )\n\n fig, axs = plot_metrics(sub_results, plot_all=False)\n fig.suptitle(f\"Subclustering for cluster {label}, reembed={reembed}\")\n stashfig(f\"sub-cluster-profile-label={label}-reembed={reembed}\")\n plt.close()\n all_sub_results.append(sub_results)\n\n# %% [markdown]\n# ##\n# sub_ks = [(2, 4), (0,), (3, 4), (3,), (2, 3), (0,), (4,)]\n# sub_kws = [(4,), (0,), (4,), (3, 4), (2, 3), (3,), (3, 4, 5)]\nif not reembed:\n sub_ks = [(4,), (4,), (3,), (2, 3, 4), (0,), (3,)]\nelse:\n pass\n\n\nfor i, label in enumerate(uni_labels):\n ks = sub_ks[i]\n sub_results = all_sub_results[i]\n sub_X = sub_data[i][\"X\"]\n sub_left_inds = sub_data[i][\"left_inds\"]\n sub_right_inds = sub_data[i][\"right_inds\"]\n sub_lp_inds = sub_data[i][\"left_pair_inds\"]\n sub_rp_inds = sub_data[i][\"right_pair_inds\"]\n sub_meta = sub_data[i][\"meta\"]\n\n fig, axs = plot_metrics(sub_results)\n fig.suptitle(f\"Subclustering for cluster {label}, reembed={reembed}\")\n for ax in axs[:-1]:\n for k in ks:\n ax.axvline(k, linestyle=\"--\", color=\"red\", linewidth=2)\n stashfig(f\"sub-cluster-metrics-label={label}-reembed={reembed}\" + basename)\n plt.close()\n\n for k in ks:\n if k != 0:\n sub_basename = f\"-label={label}-subk={k}-reembed={reembed}\" + basename\n sub_basetitle = f\"Subcluster for {label}, subk={k}, reembed={reembed},\"\n sub_basetitle += f\" metric={metric}, k={k}, n_components={n_components}\"\n\n ind = sub_results[sub_results[\"k\"] == k][metric].idxmax()\n sub_model = sub_results.loc[ind, \"model\"]\n sub_left_model = sub_model\n sub_right_model = sub_model\n\n sub_pred_side = composite_predict(\n sub_X,\n sub_left_inds,\n sub_right_inds,\n sub_left_model,\n sub_right_model,\n relabel=True,\n )\n\n ax = stacked_barplot(\n sub_pred_side,\n sub_meta[\"merge_class\"].values,\n color_dict=CLASS_COLOR_DICT,\n legend_ncol=6,\n )\n ax.set_title(sub_basetitle)\n stashfig(f\"barplot\" + sub_basename)\n plt.close()\n\n fig, ax = plot_cluster_pairs(\n sub_X,\n sub_left_inds,\n sub_right_inds,\n sub_left_model,\n sub_right_model,\n sub_meta[\"merge_class\"].values,\n )\n fig.suptitle(sub_basetitle, y=1)\n stashfig(f\"pairs\" + sub_basename)\n plt.close()\n\n sub_adj = sub_data[i][\"adj\"]\n sub_meta[\"sub_pred_side\"] = sub_pred_side\n\n sub_pred_var = f\"c{label}_sub_pred_side\"\n meta[sub_pred_var] = \"\"\n meta.loc[\n pred == label, sub_pred_var\n ] = sub_pred_side # TODO indexing is dangerous here\n meta[f\"c{label}_sub_pred\"] = \"\"\n meta.loc[pred == label, f\"c{label}_sub_pred\"] = composite_predict(\n sub_X,\n sub_left_inds,\n sub_right_inds,\n sub_left_model,\n sub_right_model,\n relabel=False,\n )\n meta[f\"is_c{label}\"] = pred == label\n fig, ax = plt.subplots(1, 1, figsize=(20, 20))\n adjplot(\n adj,\n ax=ax,\n meta=meta,\n sort_class=[\"pred_side\", sub_pred_var],\n class_order=\"group_signal_flow\",\n colors=\"merge_class\",\n palette=CLASS_COLOR_DICT,\n item_order=[\"merge_class\", \"signal_flow\"],\n highlight=f\"is_c{label}\",\n highlight_kws=dict(color=\"red\", linestyle=\"-\", linewidth=1),\n plot_type=\"scattermap\",\n sizes=(0.5, 1),\n )\n fig.suptitle(sub_basetitle, y=0.94)\n stashfig(\"full-adj\" + sub_basename)\n plt.close()\n# %% [markdown]\n# ##\n\ncols = meta.columns\nsub_pred_side_cols = []\nsub_pred_cols = []\nfor c in cols:\n if \"_sub_pred\" in c:\n if \"_side\" in c:\n sub_pred_side_cols.append(c)\n else:\n sub_pred_cols.append(c)\n\nmeta[\"total_pred\"] = \"\"\nmeta[\"total_pred\"] = meta[\"pred\"].astype(str) + \"-\"\nmeta[\"total_pred_side\"] = \"\"\nmeta[\"total_pred_side\"] = meta[\"pred_side\"].astype(str) + \"-\"\nmeta[\"sub_pred\"] = \"\"\nmeta[\"sub_pred_side\"] = \"\"\n\nfor c in sub_pred_cols:\n meta[\"total_pred\"] += meta[c].astype(str)\n meta[\"sub_pred\"] += meta[c].astype(str)\n\nfor c in sub_pred_side_cols:\n meta[\"sub_pred_side\"] += meta[c].astype(str)\n meta[\"total_pred_side\"] += meta[c].astype(str)\n\n# %% [markdown]\n# ##\nmeta[\"lvl2_signal_flow\"] = meta[\"total_pred\"].map(\n meta.groupby(\"total_pred\")[\"signal_flow\"].mean()\n)\n\nfig, ax = plt.subplots(1, 1, figsize=(20, 20))\nadjplot(\n adj,\n ax=ax,\n meta=meta,\n sort_class=[\"hemisphere\", \"pred\", \"sub_pred\"],\n class_order=\"lvl2_signal_flow\",\n colors=\"merge_class\",\n palette=CLASS_COLOR_DICT,\n item_order=[\"merge_class\", \"signal_flow\"],\n plot_type=\"scattermap\",\n sizes=(0.5, 1),\n)\nfig.suptitle(f\"2-level hierarchy clustering, reembed={reembed}\" + basetitle, y=0.94)\nstashfig(\"lvl2-full-adj\" + sub_basename)\n\nfig, ax = plt.subplots(1, 1, figsize=(20, 20))\nadjplot(\n adj,\n ax=ax,\n meta=meta,\n sort_class=[\"hemisphere\", \"pred\", \"sub_pred\"],\n class_order=\"lvl2_signal_flow\",\n colors=\"merge_class\",\n palette=CLASS_COLOR_DICT,\n item_order=[\"rand\"],\n plot_type=\"scattermap\",\n sizes=(0.5, 1),\n)\nfig.suptitle(f\"2-level hierarchy clustering, reembed={reembed}\" + basetitle, y=0.94)\nstashfig(\"lvl2-full-adj-rand\" + sub_basename)\n\n# %% [markdown]\n# ##\nfig, ax = plt.subplots(1, 1, figsize=(15, 20))\nax = stacked_barplot(\n meta[\"total_pred_side\"].values,\n meta[\"merge_class\"].values,\n color_dict=CLASS_COLOR_DICT,\n legend_ncol=6,\n ax=ax,\n norm_bar_width=False,\n)\n\nstashfig(\"lvl2-barplot\" + sub_basename)\n\n# %% [markdown]\n# ##\nimport pymaid\nfrom src.pymaid import start_instance\n\n\nstart_instance()\n\nfor tp in meta[\"total_pred\"].unique()[:10]:\n ids = list(meta[meta[\"total_pred\"] == tp].index.values)\n ids = [int(i) for i in ids]\n fig, ax = plt.subplots(1, 1, figsize=(10, 10))\n skeleton_color_dict = dict(\n zip(meta.index, np.vectorize(CLASS_COLOR_DICT.get)(meta[\"merge_class\"]))\n )\n pymaid.plot2d(ids, color=skeleton_color_dict, ax=ax)\n ax.axis(\"equal\")\n stashfig(f\"test-plot2d-{tp}\")\n\n# %% [markdown]\n# ##\n\n\n# %%\n",
"# %% [markdown]\n# # Imports\nimport os\nimport random\nfrom operator import itemgetter\nfrom pathlib import Path\n\nimport colorcet as cc\nimport matplotlib.colors as mplc\nimport matplotlib.pyplot as plt\nimport networkx as nx\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\n\nfrom graspy.cluster import AutoGMMCluster, GaussianCluster\nfrom graspy.embed import AdjacencySpectralEmbed, LaplacianSpectralEmbed\nfrom graspy.plot import gridplot, heatmap, pairplot\nfrom graspy.utils import symmetrize\nfrom src.data import load_metagraph\nfrom src.embed import ase, lse, preprocess_graph\nfrom src.graph import MetaGraph\nfrom src.io import savefig, saveobj, saveskels\nfrom src.visualization import (\n bartreeplot,\n get_color_dict,\n get_colors,\n remove_spines,\n sankey,\n screeplot,\n)\n\nFNAME = os.path.basename(__file__)[:-3]\nprint(FNAME)\n\nSAVESKELS = True\nSAVEFIGS = True\nBRAIN_VERSION = \"2020-01-21\"\n\nsns.set_context(\"talk\")\n\nbase_path = Path(\"maggot_models/data/raw/Maggot-Brain-Connectome/\")\n\n\ndef stashfig(name, **kws):\n savefig(name, foldername=FNAME, save_on=SAVEFIGS, **kws)\n\n\ndef stashskel(name, ids, labels, colors=None, palette=None, **kws):\n saveskels(\n name,\n ids,\n labels,\n colors=colors,\n palette=None,\n foldername=FNAME,\n save_on=SAVESKELS,\n **kws,\n )\n\n\ndef threshold_sweep(edgelist_df, max_pair_edgelist_df, start=0, stop=0.3, steps=20):\n threshs = np.linspace(start, stop, steps)\n rows = []\n for threshold in threshs:\n thresh_df = max_pair_edge_df[max_pair_edge_df[\"weight\"] > threshold]\n p_sym = len(thresh_df[thresh_df[\"edge pair counts\"] == 2]) / len(thresh_df)\n p_edges_left = (\n thresh_df[\"edge pair counts\"].sum()\n / max_pair_edge_df[\"edge pair counts\"].sum()\n )\n temp_df = edgelist_df[edgelist_df[\"max_weight\"] > threshold]\n p_syns_left = temp_df[\"weight\"].sum() / edgelist_df[\"weight\"].sum()\n row = {\n \"threshold\": threshold,\n \"Prop. paired edges symmetric\": p_sym,\n \"Prop. edges left\": p_edges_left,\n \"Prop. synapses left\": p_syns_left,\n }\n rows.append(row)\n return pd.DataFrame(rows)\n\n\n# %% [markdown]\n# # throw out all edges to or from any cell with...\n# # threshold curves for cells w > 100 dendritic inputs\n# # threshold curves for cells w > 50 dendritic inputs\n# # do the thresholding based on percent input\n\nbase_path = Path(\n \"maggot_models/data/raw/Maggot-Brain-Connectome/4-color-matrices_Brain/\"\n)\nsub_path = Path(\"2020-01-21/input_counts.csv\")\ninput_path = base_path / sub_path\ninput_df = pd.read_csv(input_path)\ninput_df = input_df.set_index(\"skeleton_id\")\ninput_thresh = 100\nremove_inds = input_df[input_df[\" dendrite_inputs\"] < input_thresh].index\n\ngraph_type = \"Gadn\"\nmg = load_metagraph(graph_type, version=BRAIN_VERSION)\ng = mg.g\nmeta = mg.meta\nremove_pdiff = True\nif remove_pdiff:\n keep_inds = np.where(~mg[\"is_pdiff\"])[0]\n mg = mg.reindex(keep_inds)\nedgelist_df = mg.to_edgelist(remove_unpaired=True)\nedgelist_df[\"source\"] = edgelist_df[\"source\"].astype(\"int64\")\nedgelist_df[\"target\"] = edgelist_df[\"target\"].astype(\"int64\")\n\nn_paired_edges = len(edgelist_df)\n# get rid of edges where the target is a low dendritic input node\nedgelist_df = edgelist_df[~edgelist_df[\"target\"].isin(remove_inds)]\nn_left_edges = len(edgelist_df)\n\nmax_pair_edge_df = edgelist_df.groupby(\"edge pair ID\", sort=False).max()\nedge_max_weight_map = dict(zip(max_pair_edge_df.index.values, max_pair_edge_df.values))\nedgelist_df[\"max_weight\"] = itemgetter(*edgelist_df[\"edge pair ID\"])(\n edge_max_weight_map\n)\n\nthresh_result_df = threshold_sweep(edgelist_df, max_pair_edge_df)\n\nfig, ax = plt.subplots(1, 1, figsize=(10, 6))\nsns.lineplot(\n data=thresh_result_df, x=\"threshold\", y=\"Prop. paired edges symmetric\", ax=ax\n)\nremove_spines(ax)\nax_right = plt.twinx(ax)\nsns.lineplot(\n data=thresh_result_df,\n x=\"threshold\",\n y=\"Prop. edges left\",\n ax=ax_right,\n color=\"orange\",\n label=\"Edges\",\n)\nremove_spines(ax_right)\nsns.lineplot(\n data=thresh_result_df,\n x=\"threshold\",\n y=\"Prop. synapses left\",\n ax=ax_right,\n color=\"green\",\n label=\"Synapses\",\n)\nax_right.set_ylabel(\"Prop. left\")\nax.set_title(\n f\"Min dendridic input = {input_thresh} (removed {n_paired_edges - n_left_edges} edges)\"\n)\npad = 0.02\nax.set_ylim((0 - pad, 1 + pad))\nax_right.set_ylim((0 - pad, 1 + pad))\nplt.legend(bbox_to_anchor=(1.08, 1), loc=2, borderaxespad=0.0)\nstashfig(f\"min-dend-{input_thresh}-threshold-sweep-{graph_type}\")\n# %% [markdown]\n# # get number of inputs to kenyon cells\n# # just list the number of connections onto each kenyon cell, by claw number\nplt.style.use(\"seaborn-whitegrid\")\nsns.set_context(\"talk\")\ngraph_type = \"Gad\"\nmg = load_metagraph(graph_type, version=BRAIN_VERSION)\nedgelist_df = mg.to_edgelist()\nadj = mg.adj\nclass_labels = mg.meta[\"Class 1\"].fillna(\"\")\nsubclass_labels = mg.meta[\"Class 2\"].fillna(\"\")\nkc_inds = np.where(class_labels == \"KC\")[0]\nfor i in range(1, 7):\n name = f\"{i}claw\"\n sub_edgelist_df = edgelist_df[edgelist_df[\"target Class 2\"] == name]\n ids = sub_edgelist_df[\"target\"].unique()\n # fig, ax = plt.subplots(1, 1, figsize=(15, 5))\n fig = plt.figure(figsize=(20, 7))\n ax = plt.subplot2grid((1, 5), (0, 0), colspan=4)\n ax2 = plt.subplot2grid((1, 5), (0, 4), colspan=1)\n sns.stripplot(data=sub_edgelist_df, y=\"weight\", x=\"target\", ax=ax, order=ids)\n for tick in ax.get_xticklabels():\n tick.set_rotation(90)\n ax.set_title(name + \" input weights\")\n # remove_spines(ax, keep_corner=True)\n mins = []\n ticks = ax.get_xticks()\n color = sns.color_palette(\"deep\", desat=1, n_colors=2)[1]\n for j, cell_id in enumerate(ids):\n cell_df = sub_edgelist_df[sub_edgelist_df[\"target\"] == cell_id]\n cell_df = cell_df.sort_values(\"weight\", ascending=False)\n cell_df = cell_df.iloc[:i, :]\n min_max_weight = cell_df[\"weight\"].min()\n ax.text(\n j,\n min_max_weight,\n min_max_weight,\n fontsize=\"small\",\n horizontalalignment=\"center\",\n verticalalignment=\"bottom\",\n )\n mins.append(min_max_weight)\n sns.violinplot(\n mins, ax=ax2, orient=\"v\", inner=\"quart\", color=color, alpha=0.8, saturation=1\n )\n median = np.median(mins)\n ax2.text(\n 0,\n median,\n f\"{median:.0f}\",\n horizontalalignment=\"center\",\n verticalalignment=\"center\",\n backgroundcolor=color,\n alpha=0.8,\n )\n # ax2.yaxis.set_major_locator(plt.NullLocator())\n ax2.set_ylim(ax.get_ylim())\n ax2.yaxis.set_ticks([])\n ax2.set_title(\"\")\n stashfig(name + \"-input-weights\")\n\nname = \"all KC\"\nkc_edgelist_df = edgelist_df[edgelist_df[\"target Class 1\"] == \"KC\"]\nfig, ax = plt.subplots(1, 1, figsize=(15, 5))\nsns.stripplot(\n data=kc_edgelist_df,\n y=\"weight\",\n x=\"target Class 2\",\n ax=ax,\n order=[f\"{i}claw\" for i in range(1, 7)],\n jitter=0.45,\n)\nfor tick in ax.get_xticklabels():\n tick.set_rotation(90)\nax.set_title(name + \" input weights\")\n# remove_spines(ax, keep_corner=True)\nstashfig(\"all-kc-input-weights\")\n\n# %% [markdown]\n# # plot the distribution of # of dendritic / axonic inputs\n\ngraph_type = \"Gad\"\nmg = load_metagraph(graph_type, version=BRAIN_VERSION)\nmeta = mg.meta\nmeta.loc[input_df.index, \"dendrite_input\"] = input_df[\" dendrite_inputs\"]\nmeta.loc[input_df.index, \"axon_input\"] = input_df[\" axon_inputs\"]\n\n\ndef filter(string):\n string = string.replace(\"akira\", \"\")\n string = string.replace(\"Lineage\", \"\")\n string = string.replace(\"*\", \"\")\n string = string.strip(\"_\")\n return string\n\n\nlineages = meta[\"lineage\"]\nlineages = np.vectorize(filter)(lineages)\nmeta[\"lineage\"] = lineages\n\n\nn_rows = 6\nfig, axs = plt.subplots(n_rows, 1, figsize=(15, 30), sharey=True)\nuni_lineages = np.unique(meta[\"lineage\"])\nn_lineages = len(uni_lineages)\nn_per_row = n_lineages // n_rows\nfor i in range(n_rows):\n ax = axs[i]\n temp_lineages = uni_lineages[i * n_per_row : (i + 1) * n_per_row]\n temp_df = meta[meta[\"lineage\"].isin(temp_lineages)]\n sns.stripplot(\n data=temp_df, x=\"lineage\", y=\"dendrite_input\", ax=ax, palette=\"deep\", jitter=0.4\n )\n for tick in ax.get_xticklabels():\n tick.set_rotation(90)\n ax.set_xlabel(\"\")\n remove_spines(ax)\n ax.yaxis.set_major_locator(plt.MaxNLocator(3))\n ax.xaxis.set_tick_params(length=0)\nplt.tight_layout()\nstashfig(\"all-lineage-dendrite-input\")\n\n# %% [markdown]\n# # Plot this but by cell class\nn_rows = 3\nuni_lineages = np.unique(meta[\"Merge Class\"])\nn_lineages = len(uni_lineages)\nn_per_row = n_lineages // n_rows\nfig, axs = plt.subplots(n_rows + 1, 1, figsize=(15, 30), sharey=True)\nfor i in range(n_rows):\n ax = axs[i]\n temp_lineages = uni_lineages[i * n_per_row : (i + 1) * n_per_row]\n temp_df = meta[meta[\"Merge Class\"].isin(temp_lineages)]\n sns.stripplot(\n data=temp_df,\n x=\"Merge Class\",\n y=\"dendrite_input\",\n ax=ax,\n palette=\"deep\",\n jitter=0.4,\n )\n for tick in ax.get_xticklabels():\n tick.set_rotation(90)\n ax.set_xlabel(\"\")\n remove_spines(ax)\n ax.yaxis.set_major_locator(plt.MaxNLocator(3))\n ax.xaxis.set_tick_params(length=0)\nxlim = ax.get_xlim()\nax = axs[-1]\ntemp_lineages = uni_lineages[(i + 1) * n_per_row :]\ntemp_df = meta[meta[\"Merge Class\"].isin(temp_lineages)]\nsns.stripplot(\n data=temp_df, x=\"Merge Class\", y=\"dendrite_input\", ax=ax, palette=\"deep\", jitter=0.4\n)\nfor tick in ax.get_xticklabels():\n tick.set_rotation(90)\nax.set_xlabel(\"\")\nremove_spines(ax)\nax.yaxis.set_major_locator(plt.MaxNLocator(3))\nax.xaxis.set_tick_params(length=0)\nax.set_xlim(xlim)\nplt.tight_layout()\nstashfig(\"all-merge-class-dendrite-input\")\n\n# %% [markdown]\n# # plot some kind of asymmetry score by lineage\n# # - proportion of edges onto a lineage which are asymmetric after thresholding\n# # - IOU score?\n# # - something else?\n\ngraph_type = \"Gadn\"\nmg = load_metagraph(graph_type, version=BRAIN_VERSION)\ng = mg.g\nmeta = mg.meta\n\nlineages = meta[\"lineage\"]\nlineages = np.vectorize(filter)(lineages)\nmeta[\"lineage\"] = lineages\n\nedgelist_df = mg.to_edgelist(remove_unpaired=True)\nedgelist_df[\"source\"] = edgelist_df[\"source\"].astype(\"int64\")\nedgelist_df[\"target\"] = edgelist_df[\"target\"].astype(\"int64\")\n\nn_paired_edges = len(edgelist_df)\n# get rid of edges where the target is a low dendritic input node\nedgelist_df = edgelist_df[~edgelist_df[\"target\"].isin(remove_inds)]\nn_left_edges = len(edgelist_df)\n\nmax_pair_edge_df = edgelist_df.groupby(\"edge pair ID\").max()\nedge_max_weight_map = dict(\n zip(max_pair_edge_df.index.values, max_pair_edge_df[\"weight\"])\n)\nedgelist_df[\"max_weight\"] = itemgetter(*edgelist_df[\"edge pair ID\"])(\n edge_max_weight_map\n)\n\nthreshold = 0.0\nthresh_df = max_pair_edge_df[max_pair_edge_df[\"weight\"] > threshold]\n\nsource_pair_ids = np.unique(max_pair_edge_df[\"source Pair ID\"])\ntarget_pair_ids = np.unique(max_pair_edge_df[\"target Pair ID\"])\npair_ids = np.union1d(source_pair_ids, target_pair_ids)\n\nrows = []\nfor pid in pair_ids:\n temp_df = thresh_df[\n (thresh_df[\"source Pair ID\"] == pid) | (thresh_df[\"target Pair ID\"] == pid)\n ]\n\n if len(temp_df) > 0:\n iou = len(temp_df[temp_df[\"edge pair counts\"] == 2]) / len(temp_df)\n else:\n iou = 0\n\n temp_meta = meta[meta[\"Pair ID\"] == pid]\n lineage = temp_meta[\"lineage\"].values[0]\n row = {\"IOU\": iou, \"lineage\": lineage}\n rows.append(row)\n\nlineage_iou_df = pd.DataFrame(rows)\n\nn_rows = 6\nfig, axs = plt.subplots(n_rows, 1, figsize=(15, 30), sharey=True)\nuni_lineages = np.unique(lineage_iou_df[\"lineage\"])\nn_lineages = len(uni_lineages)\nn_per_row = n_lineages // n_rows\nfor i in range(n_rows):\n ax = axs[i]\n temp_lineages = uni_lineages[i * n_per_row : (i + 1) * n_per_row]\n temp_df = lineage_iou_df[lineage_iou_df[\"lineage\"].isin(temp_lineages)]\n sns.stripplot(data=temp_df, x=\"lineage\", y=\"IOU\", ax=ax, palette=\"deep\", jitter=0.4)\n for tick in ax.get_xticklabels():\n tick.set_rotation(90)\n ax.set_xlabel(\"\")\n remove_spines(ax)\n ax.yaxis.set_major_locator(plt.MaxNLocator(3))\n ax.xaxis.set_tick_params(length=0)\nplt.suptitle(f\"IOU after threshold = {threshold}\", y=1.02)\nplt.tight_layout()\nstashfig(f\"all-lineage-iou-{threshold}\")\n\n# %% [markdown]\n# # Do the same by cell class\n\nrows = []\nfor pid in pair_ids:\n temp_df = thresh_df[\n (thresh_df[\"source Pair ID\"] == pid) | (thresh_df[\"target Pair ID\"] == pid)\n ]\n\n if len(temp_df) > 0:\n iou = len(temp_df[temp_df[\"edge pair counts\"] == 2]) / len(temp_df)\n else:\n iou = 0\n\n temp_meta = meta[meta[\"Pair ID\"] == pid]\n lineage = temp_meta[\"Merge Class\"].values[0]\n row = {\"IOU\": iou, \"Merge Class\": lineage}\n rows.append(row)\n\nlineage_iou_df = pd.DataFrame(rows)\n\nn_rows = 3\nfig, axs = plt.subplots(n_rows, 1, figsize=(15, 30), sharey=True)\nuni_lineages = np.unique(lineage_iou_df[\"Merge Class\"])\nn_lineages = len(uni_lineages)\nn_per_row = n_lineages // n_rows\nfor i in range(n_rows):\n ax = axs[i]\n temp_lineages = uni_lineages[i * n_per_row : (i + 1) * n_per_row]\n temp_df = lineage_iou_df[lineage_iou_df[\"Merge Class\"].isin(temp_lineages)]\n sns.stripplot(\n data=temp_df, x=\"Merge Class\", y=\"IOU\", ax=ax, palette=\"deep\", jitter=0.4\n )\n for tick in ax.get_xticklabels():\n tick.set_rotation(90)\n ax.set_xlabel(\"\")\n remove_spines(ax)\n ax.yaxis.set_major_locator(plt.MaxNLocator(3))\n ax.xaxis.set_tick_params(length=0)\nplt.suptitle(f\"IOU after threshold = {threshold}\", y=1.02)\nplt.tight_layout()\nstashfig(f\"all-class-iou-{threshold}\")\n",
"# %% [markdown]\n# # THE MIND OF A MAGGOT\n\n# %% [markdown]\n# ## Imports\nimport os\nimport time\nimport warnings\n\nimport colorcet as cc\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport matplotlib.transforms as transforms\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nfrom anytree import LevelOrderGroupIter, NodeMixin\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom scipy.linalg import orthogonal_procrustes\nfrom scipy.optimize import linear_sum_assignment\nfrom sklearn.exceptions import ConvergenceWarning\nfrom sklearn.metrics import adjusted_rand_score\nfrom sklearn.utils.testing import ignore_warnings\nfrom tqdm import tqdm\n\nimport pymaid\nfrom graspy.cluster import GaussianCluster\nfrom graspy.embed import AdjacencySpectralEmbed, LaplacianSpectralEmbed, selectSVD\nfrom graspy.models import DCSBMEstimator, RDPGEstimator, SBMEstimator\nfrom graspy.plot import heatmap, pairplot\nfrom graspy.simulations import rdpg\nfrom graspy.utils import augment_diagonal, binarize, pass_to_ranks\nfrom src.cluster import (\n MaggotCluster,\n add_connections,\n compute_pairedness_bipartite,\n crossval_cluster,\n fit_and_score,\n get_paired_inds,\n make_ellipses,\n plot_cluster_pairs,\n plot_metrics,\n predict,\n)\nfrom src.data import load_metagraph\nfrom src.graph import MetaGraph, preprocess\nfrom src.hierarchy import signal_flow\nfrom src.io import savecsv, savefig\nfrom src.pymaid import start_instance\nfrom src.visualization import (\n CLASS_COLOR_DICT,\n adjplot,\n barplot_text,\n gridmap,\n matrixplot,\n set_axes_equal,\n stacked_barplot,\n)\n\nwarnings.filterwarnings(action=\"ignore\", category=ConvergenceWarning)\n\nFNAME = os.path.basename(__file__)[:-3]\nprint(FNAME)\n\nrc_dict = {\n \"axes.spines.right\": False,\n \"axes.spines.top\": False,\n \"axes.formatter.limits\": (-3, 3),\n \"figure.figsize\": (6, 3),\n \"figure.dpi\": 100,\n}\nfor key, val in rc_dict.items():\n mpl.rcParams[key] = val\ncontext = sns.plotting_context(context=\"talk\", font_scale=1, rc=rc_dict)\nsns.set_context(context)\n\nPLOT_MODELS = True\n\nnp.random.seed(8888)\n\n\ndef stashfig(name, **kws):\n savefig(name, foldername=FNAME, save_on=True, **kws)\n\n\ndef stashcsv(df, name, **kws):\n savecsv(df, name)\n\n\n# %% [markdown]\n# ## Load data\n# In this case we are working with `G`, the directed graph formed by summing the edge\n# weights of the 4 different graph types. Preprocessing here includes removing\n# partially differentiated cells, and cutting out the lowest 5th percentile of nodes in\n# terms of their number of incident synapses. 5th percentile ~= 12 synapses. After this,\n# the largest connected component is used.\n\nmg = load_metagraph(\"G\", version=\"2020-04-01\")\nmg = preprocess(\n mg,\n threshold=0,\n sym_threshold=False,\n remove_pdiff=True,\n binarize=False,\n weight=\"weight\",\n)\nmeta = mg.meta\n\n# plot where we are cutting out nodes based on degree\ndegrees = mg.calculate_degrees()\nfig, ax = plt.subplots(1, 1, figsize=(5, 2.5))\nsns.distplot(np.log10(degrees[\"Total edgesum\"]), ax=ax)\nq = np.quantile(degrees[\"Total edgesum\"], 0.05)\nax.axvline(np.log10(q), linestyle=\"--\", color=\"r\")\nax.set_xlabel(\"log10(total synapses)\")\n\n# remove low degree neurons\nidx = meta[degrees[\"Total edgesum\"] > q].index\nmg = mg.reindex(idx, use_ids=True)\n\n# remove center neurons # FIXME\nidx = mg.meta[mg.meta[\"hemisphere\"].isin([\"L\", \"R\"])].index\nmg = mg.reindex(idx, use_ids=True)\n\nmg = mg.make_lcc()\nmg.calculate_degrees(inplace=True)\nmeta = mg.meta\n\nadj = mg.adj\nmeta[\"inds\"] = range(len(meta))\n\n# %% [markdown]\n# ## Normalize\nnp.random.seed(8888)\nmc = MaggotCluster(\n \"0\",\n adj=adj,\n meta=meta,\n n_init=50,\n stashfig=stashfig,\n max_clusters=4,\n n_components=None,\n embed=\"unscaled_ase\",\n # reembed=True,\n realign=True,\n normalize=True,\n)\nmc.fit_candidates()\n\n# %% [markdown]\n# ##\nmc.plot_model(4)\n# %% [markdown]\n# ##\n\nmc.plot_model(6)\n\n# %% [markdown]\n# ##\nimport n_sphere\n\nnorm_embed = mc.X_\nlabels = meta[\"merge_class\"].values\nnorm_embed_spherical = n_sphere.convert_spherical(norm_embed)\nnorm_embed_spherical = norm_embed_spherical[:, 1:] # chop off R dimension\npg = pairplot(norm_embed_spherical, labels=labels, palette=CLASS_COLOR_DICT)\npg._legend.remove()\n\n\n# %% [markdown]\n# ##\n\nfrom sklearn.cluster import AgglomerativeClustering\n\nfor k in range(2, 10):\n ag = AgglomerativeClustering(n_clusters=k, affinity=\"cosine\", linkage=\"average\")\n pred_labels = ag.fit_predict(norm_embed)\n\n ax = stacked_barplot(pred_labels, labels, color_dict=CLASS_COLOR_DICT)\n ax.set_title(f\"k={k}\")\n# %% [markdown]\n# ## new\nnp.random.seed(8888)\nmc = MaggotCluster(\n \"0\",\n adj=adj,\n meta=meta,\n n_init=50,\n stashfig=stashfig,\n max_clusters=8,\n n_components=None,\n embed=\"unscaled_ase\",\n reembed=True,\n realign=True,\n)\nmc.fit_candidates()\nmc.plot_model(6)\nmc.plot_model(7)\nmc.select_model(6)\n\nnp.random.seed(9999)\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n node.fit_candidates()\n\nsub_ks = [(2, 3, 4, 5), (2, 3, 4), (2, 4, 5, 6), (2, 3, 4), (2, 3, 4), (2, 3, 4, 5)]\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n for k in sub_ks[i]:\n node.plot_model(k)\n\n# %% [markdown]\n# ## new\n\nnp.random.seed(8888)\nmc = MaggotCluster(\n \"0\",\n adj=adj,\n meta=meta,\n n_init=50,\n stashfig=stashfig,\n max_clusters=8,\n n_components=None,\n embed=\"unscaled_ase\",\n reembed=False,\n realign=True,\n)\nmc.fit_candidates()\nmc.plot_model(6)\nmc.plot_model(7)\nmc.select_model(6)\n\nnp.random.seed(9999)\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n node.fit_candidates()\n\nsub_ks = [(2, 3, 4, 5), (2, 3, 4), (2, 4, 5, 6), (2, 3, 4), (2, 3, 4), (2, 3, 4, 5)]\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n for k in sub_ks[i]:\n node.plot_model(k)\n\n# %% [markdown]\n# ## new\n\nnp.random.seed(8888)\nmc = MaggotCluster(\n \"0\",\n adj=adj,\n meta=meta,\n n_init=50,\n stashfig=stashfig,\n max_clusters=8,\n n_components=None,\n embed=\"unscaled_ase\",\n reembed=\"masked\",\n realign=True,\n)\nmc.fit_candidates()\nmc.plot_model(6)\nmc.plot_model(7)\nmc.select_model(6)\n\nnp.random.seed(9999)\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n node.fit_candidates()\n\nsub_ks = [(2, 3, 4, 5), (2, 3, 4), (2, 4, 5, 6), (2, 3, 4), (2, 3, 4), (2, 3, 4, 5)]\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n for k in sub_ks[i]:\n node.plot_model(k)\n\n\n# %% [markdown]\n# ##\nnp.random.seed(8888)\nmc = MaggotCluster(\n \"0\",\n adj=adj,\n meta=meta,\n n_init=50,\n stashfig=stashfig,\n max_clusters=8,\n n_components=4,\n embed=\"ase\",\n realign=True,\n)\nmc.fit_candidates()\nmc.plot_model(6)\nmc.plot_model(7)\nmc.select_model(6)\n\n#%%\nnp.random.seed(9999)\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n node.fit_candidates()\n\nsub_ks = [(2, 3, 4, 5), (2, 3, 4), (2, 4, 5, 6), (2, 3, 4), (2, 3, 4), (2, 3, 4, 5)]\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n for k in sub_ks[i]:\n node.plot_model(k)\n\n# %% [markdown]\n# ##\nnp.random.seed(8888)\n\nmc = MaggotCluster(\n \"0\",\n adj=adj,\n meta=meta,\n n_init=50,\n stashfig=stashfig,\n max_clusters=8,\n n_components=4,\n embed=\"ase\",\n realign=False,\n)\nmc.fit_candidates()\nmc.plot_model(6)\nmc.select_model(6)\n\nnp.random.seed(9999)\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n node.fit_candidates()\n\nsub_ks = [(2, 3, 4, 5), (2, 3, 4), (2, 4, 5, 6), (2, 3, 4), (2, 3, 4), (2, 3, 4, 5)]\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n for k in sub_ks[i]:\n node.plot_model(k)\n\n# %% [markdown]\n# ##\nnp.random.seed(8888)\n\nmc = MaggotCluster(\n \"0\",\n adj=adj,\n meta=meta,\n n_init=50,\n stashfig=stashfig,\n max_clusters=8,\n n_components=4,\n embed=\"unscaled_ase\",\n realign=False,\n)\nmc.fit_candidates()\nmc.plot_model(6)\nmc.select_model(6)\n\nnp.random.seed(9999)\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n node.fit_candidates()\n\nsub_ks = [(2, 3, 4, 5), (2, 3, 4), (2, 4, 5, 6), (2, 3, 4), (2, 3, 4), (2, 3, 4, 5)]\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n for k in sub_ks[i]:\n node.plot_model(k)\n# %% [markdown]\n# ##\nnp.random.seed(8888)\n\nmc = MaggotCluster(\n \"0\",\n adj=adj,\n meta=meta,\n n_init=50,\n stashfig=stashfig,\n max_clusters=8,\n n_components=4,\n embed=\"ase\",\n reembed=True,\n)\nmc.fit_candidates()\nmc.plot_model(6)\nmc.select_model(6)\n\nnp.random.seed(9999)\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n node.fit_candidates()\n\nsub_ks = [(2, 3, 4, 5), (2, 3, 4), (2, 4, 5, 6), (2, 3, 4), (2, 3, 4), (2, 3, 4, 5)]\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n for k in sub_ks[i]:\n node.plot_model(k)\n\n# # %% [markdown]\n# # ##\n# np.random.seed(8888)\n\n# mc = MaggotCluster(\n# \"0\",\n# adj=adj,\n# meta=meta,\n# n_init=50,\n# stashfig=stashfig,\n# max_clusters=8,\n# n_components=4,\n# embed=\"ase\",\n# reembed=True,\n# )\n# mc.fit_candidates()\n# mc.select_model(6)\n\n# np.random.seed(9999)\n# for i, node in enumerate(mc.get_lowest_level()):\n# print(node.name)\n# print()\n# node.fit_candidates()\n\n# sub_ks = [(2, 3, 4, 5), (2, 3, 4), (2, 4, 5, 6), (2, 3, 4), (2, 3, 4), (2, 3, 4, 5)]\n# for i, node in enumerate(mc.get_lowest_level()):\n# print(node.name)\n# print()\n# for k in sub_ks[i]:\n# node.plot_model(k)\n\n\n# %%\n\n# %% [markdown]\n# ##\n\nnp.random.seed(8888)\n\nmc = MaggotCluster(\n \"0\",\n adj=adj,\n meta=meta,\n n_init=50,\n stashfig=stashfig,\n max_clusters=8,\n n_components=None,\n embed=\"unscaled_ase\",\n realign=False,\n reembed=True,\n)\nmc.fit_candidates()\nmc.plot_model(6)\nmc.select_model(6)\n\n# %% [markdown]\n# ##\nnp.random.seed(9999)\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n node.fit_candidates()\n\nsub_ks = [(2, 3, 4, 5), (2, 3, 4), (2, 4, 5, 6), (2, 3, 4), (2, 3, 4), (2, 3, 4, 5)]\nfor i, node in enumerate(mc.get_lowest_level()):\n print(node.name)\n print()\n for k in sub_ks[i]:\n node.plot_model(k)\n\n\n# %% focus on the antenal lobey cluster\nat_node = mc.get_lowest_level()[2]\nat_node.select_model(2) # or 6\n\nfor i, node in enumerate(at_node.get_lowest_level()):\n print(node.name)\n print()\n node.fit_candidates()\n\n",
"#%% Imports and file loading\nimport glob\nimport json\nimport pprint\nimport sys\nfrom operator import itemgetter\nfrom os import listdir\nfrom pathlib import Path\n\nimport networkx as nx\nimport numpy as np\nimport pandas as pd\n\nimport pymaid\nfrom graspy.plot import gridplot\nfrom src.data import load_networkx\nfrom src.pymaid import start_instance\n\n# File locations\nbase_path = Path(\"./maggot_models/data/raw/Maggot-Brain-Connectome/\")\n\ndata_path = base_path / \"4-color-matrices_Brain\"\n\ndata_date_graphs = \"2020-04-23\"\n\ngraph_types = [\"axon-axon\", \"axon-dendrite\", \"dendrite-axon\", \"dendrite-dendrite\"]\n\ninput_counts_file = \"input_counts\"\n\npair_file = base_path / \"pairs/pairs-2020-02-27.csv\"\n\noutput_name = \"2020-04-23\"\noutput_path = Path(f\"maggot_models/data/processed/{output_name}\")\n\n# sys.stdout = open(f\"maggot_models/data/logs/{output_name}.txt\", \"w\")\n\n\nprint(output_path)\n\n\nlineage_file = data_path / Path(data_date_graphs) / \"skeleton_id_vs_lineage.csv\"\n\n\ndef df_to_nx(df, meta_data_dict):\n c = df.columns.values\n c = c.astype(int)\n r = df.index.values\n df.columns = c\n if not (c == r).all():\n raise ValueError(\"Mismatching df indexing\")\n graph = nx.from_pandas_adjacency(df, create_using=nx.DiGraph)\n nx.set_node_attributes(graph, meta_data_dict)\n return graph\n\n\npriority_map = {\n \"MBON\": 1,\n \"MBIN\": 1,\n \"KC\": 1,\n \"uPN\": 1,\n \"tPN\": 1,\n \"vPN\": 1,\n \"mPN\": 1,\n \"sens\": 1,\n \"APL\": 1,\n \"LHN\": 2,\n \"CN\": 2,\n \"dVNC\": 2,\n \"dSEZ\": 2,\n \"RG\": 2,\n \"dUnk\": 2,\n \"FBN\": 3,\n \"FAN\": 3,\n \"LHN2\": 5, # used to be 4\n \"CN2\": 6, # used to be 5\n \"FB2N\": 3,\n \"FFN\": 4, # used to be 4\n \"MN2\": 3,\n \"AN2\": 3,\n \"vtd2\": 3,\n}\n\n\ndef priority(name):\n if name in priority_map:\n return priority_map[name]\n else:\n return 1000\n\n\ncheck_priority = np.vectorize(priority)\n\n\ndef get_single_class(classes):\n single_class = classes[0]\n for c in classes[1:]:\n single_class += \";\" + c\n return str(single_class)\n\n\ndef get_classes(meta, class_cols, fill_unk=False):\n all_class = []\n single_class = []\n n_class = []\n for index, row in meta.iterrows():\n classes = class_cols[row[class_cols].astype(bool)]\n all_class.append(str(classes))\n n_class.append(int(len(classes)))\n if len(classes) > 0:\n priorities = check_priority(classes)\n inds = np.where(priorities == priorities.min())[0]\n sc = get_single_class(classes[inds])\n else:\n if fill_unk:\n sc = \"unk\"\n else:\n sc = \"\"\n single_class.append(sc)\n return single_class, all_class, n_class\n\n\n# %% [markdown]\n# ##\nprint(\"Loading annotations:\\n\")\n\nstart_instance()\nannot_df = pymaid.get_annotated(\"mw neuron groups\")\n\nseries_ids = []\nfor annot_name in annot_df[\"name\"]:\n print(annot_name)\n ids = pymaid.get_skids_by_annotation(annot_name)\n name = annot_name.replace(\"mw \", \"\")\n name = name.replace(\" \", \"_\")\n indicator = pd.Series(\n index=ids, data=np.ones(len(ids), dtype=bool), name=name, dtype=bool\n )\n series_ids.append(indicator)\n print()\n\n\n# %% [markdown]\n# ##\nmeta = pd.concat(series_ids, axis=1, ignore_index=False)\nmeta.fillna(False, inplace=True)\n\nclass1_name_map = {\n \"APL\": \"APL\",\n \"dSEZ\": \"dSEZ\",\n \"dVNC\": \"dVNC\",\n \"RG\": \"RG\",\n \"picky_LN\": \"pLN\",\n \"choosy_LN\": \"cLN\",\n \"broad_LN\": \"bLN\",\n \"CN\": \"CN\",\n \"CN2\": \"CN2\",\n \"CX\": \"CX\",\n \"FAN\": \"FAN\",\n \"FB2N\": \"FB2N\",\n \"FBN\": \"FBN\",\n \"KC\": \"KC\",\n \"keystone\": \"keystone\",\n \"LHN\": \"LHN\",\n \"LHN2\": \"LHN2\",\n \"LON\": \"LON\",\n \"MBIN\": \"MBIN\",\n \"MBON\": \"MBON\",\n \"motor\": \"motor\",\n \"mPN\": \"mPN\",\n \"dUnk\": \"dUnk\",\n \"sens\": \"sens\",\n \"tPN\": \"tPN\",\n \"uPN\": \"uPN\",\n \"vPN\": \"vPN\",\n \"vtd_2ndOrder\": \"vtd2\",\n \"AN_2nd_order\": \"AN2\",\n \"MN_2nd_order\": \"MN2\",\n}\n\n\nmeta.rename(class1_name_map, axis=1, inplace=True)\n\n\n# %% [markdown]\n# ##\nclass1_cols = np.array(list(class1_name_map.values()))\n\n\nsingle_class1, all_class1, n_class1 = get_classes(meta, class1_cols, fill_unk=True)\n\nmeta[\"class1\"] = single_class1\nmeta[\"all_class1\"] = all_class1\nmeta[\"n_class1\"] = n_class1\n\n\n# %% [markdown]\n# ##\nclass2_cols = []\nfor c in meta.columns.values:\n if \"subclass\" in c:\n class2_cols.append(c)\nclass2_cols = np.array(class2_cols)\n\n\nsingle_class2, all_class2, n_class2 = get_classes(meta, class2_cols)\n\n\ndef remove_subclass(string):\n ind = string.find(\"subclass_\")\n return string[ind + len(\"subclass_\") :]\n\n\nclass2_name_map = {\n \"appetitive\": \"app\",\n \"aversive\": \"av\",\n \"neither\": \"neith\",\n \"olfactory\": \"olfac\",\n}\n\n\ndef name_mapper(string, name_map):\n if string in name_map:\n return name_map[string]\n else:\n return string\n\n\nsingle_class2 = np.vectorize(remove_subclass)(single_class2)\nsingle_class2 = np.vectorize(lambda x: name_mapper(x, class2_name_map))(single_class2)\n\nmeta[\"class2\"] = single_class2\nmeta[\"all_class2\"] = all_class2\nmeta[\"n_class2\"] = n_class2\n\n# %% [markdown]\n# ##\nprint()\nprint(\"Class 1 unique values:\")\npprint.pprint(dict(zip(*np.unique(all_class1, return_counts=True))))\nprint()\nprint(\"Class 2 unique values:\")\npprint.pprint(dict(zip(*np.unique(all_class2, return_counts=True))))\nprint()\n\n# %% [markdown]\n# ## Hemisphere\nmeta[\"hemisphere\"] = \"C\" # default is center\nleft_meta = meta[meta[\"left\"]]\nmeta.loc[left_meta.index, \"hemisphere\"] = \"L\"\nright_meta = meta[meta[\"right\"]]\nmeta.loc[right_meta.index, \"hemisphere\"] = \"R\"\n\n# %% [markdown]\n# # Pairs\n\n# Pairs (NOTE this file has some issues where some ids are repeated in multiple pairs)\npair_df = pd.read_csv(pair_file, usecols=range(2))\npair_df[\"pair_id\"] = range(len(pair_df))\n\nuni_left, left_counts = np.unique(pair_df[\"leftid\"], return_counts=True)\nuni_right, right_counts = np.unique(pair_df[\"rightid\"], return_counts=True)\n\ndup_left_inds = np.where(left_counts != 1)[0]\ndup_right_inds = np.where(right_counts != 1)[0]\ndup_left_ids = uni_left[dup_left_inds]\ndup_right_ids = uni_right[dup_right_inds]\n\nprint(\"\\n\\n\")\nif len(dup_left_inds) > 0:\n print(\"Duplicate pairs left:\")\n print(dup_left_ids)\nif len(dup_right_inds) > 0:\n print(\"Duplicate pairs right:\")\n print(dup_right_ids)\nprint(\"\\n\\n\")\n\ndrop_df = pair_df[\n pair_df[\"leftid\"].isin(dup_left_ids) | pair_df[\"rightid\"].isin(dup_right_ids)\n]\nprint(\"\\n\\n\")\nprint(\"Dropping pairs:\")\nprint(drop_df)\nprint(\"\\n\\n\")\n\npair_df.drop(drop_df.index, axis=0, inplace=True)\n\npair_ids = np.concatenate((pair_df[\"leftid\"].values, pair_df[\"rightid\"].values))\nmeta_ids = meta.index.values\nin_meta_ids = np.isin(pair_ids, meta_ids)\ndrop_ids = pair_ids[~in_meta_ids]\npair_df = pair_df[~pair_df[\"leftid\"].isin(drop_ids)]\npair_df = pair_df[~pair_df[\"rightid\"].isin(drop_ids)]\n\nleft_to_right_df = pair_df.set_index(\"leftid\")\nright_to_left_df = pair_df.set_index(\"rightid\")\nright_to_left_df.head()\n\nmeta[\"Pair\"] = -1\nmeta[\"Pair ID\"] = -1\nmeta.loc[left_to_right_df.index, \"Pair\"] = left_to_right_df[\"rightid\"]\nmeta.loc[right_to_left_df.index, \"Pair\"] = right_to_left_df[\"leftid\"]\n\nmeta.loc[left_to_right_df.index, \"Pair ID\"] = left_to_right_df[\"pair_id\"]\nmeta.loc[right_to_left_df.index, \"Pair ID\"] = right_to_left_df[\"pair_id\"]\n\n#%% Fix places where L/R labels are not the same\nprint(\"\\n\\nFinding asymmetric L/R labels\")\nfor i in range(len(meta)):\n my_id = meta.index[i]\n my_class = meta.loc[my_id, \"class1\"]\n partner_id = meta.loc[my_id, \"Pair\"]\n if partner_id != -1:\n partner_class = meta.loc[partner_id, \"class1\"]\n if partner_class != \"unk\" and my_class == \"unk\":\n print(f\"{my_id} had asymmetric class label {partner_class}, fixed\")\n meta.loc[my_id, \"class1\"] = partner_class\n elif (partner_class != my_class) and (partner_class != \"unk\"):\n msg = (\n f\"{meta.index[i]} and partner {partner_id} have different labels\"\n + f\", labels are {my_class}, {partner_class}\"\n )\n print(msg)\nprint()\n\n# %% [markdown]\n# #\n\n# Merge class (put class 1 and class 2 together as a column)\nmeta[\"merge_class\"] = \"\"\nfor i in meta.index.values:\n merge_class = meta.loc[i, \"class1\"]\n if meta.loc[i, \"class2\"] != \"\":\n merge_class += \"-\" + meta.loc[i, \"class2\"]\n meta.loc[i, \"merge_class\"] = merge_class\n\nprint()\nprint(\"Merge class unique values:\")\npprint.pprint(dict(zip(*np.unique(meta[\"merge_class\"], return_counts=True))))\nprint()\n#%% lineages\n\n\ndef filt(string):\n string = string.replace(\"akira\", \"\")\n string = string.replace(\"Lineage\", \"\")\n string = string.replace(\"lineage\", \"\")\n string = string.replace(\"*\", \"\")\n string = string.strip(\"_\")\n string = string.strip(\" \")\n string = string.replace(\"_r\", \"\")\n string = string.replace(\"_l\", \"\")\n string = string.replace(\"right\", \"\")\n string = string.replace(\"left\", \"\")\n string = string.replace(\"unknown\", \"unk\")\n return string\n\n\nlineage_df = []\n\nannot_df = pymaid.get_annotated(\"Volker\")\nfor annot_name in annot_df[\"name\"]:\n print(annot_name)\n ids = pymaid.get_skids_by_annotation(annot_name.replace(\"*\", \"\\*\"))\n name = filt(annot_name)\n print(name)\n print()\n indicator = pd.Series(\n index=ids, data=np.ones(len(ids), dtype=bool), name=name, dtype=bool\n )\n lineage_df.append(indicator)\n\nlineage_df = pd.concat(lineage_df, axis=1, ignore_index=False)\n#%%\nlineage_df = lineage_df.fillna(False)\ndata = lineage_df.values\nrow_sums = data.sum(axis=1)\nlineage_df.loc[row_sums > 1, :] = False\ncheck_row_sums = lineage_df.values.sum(axis=1)\nassert check_row_sums.max() == 1\n\ncolumns = lineage_df.columns\nlineages = []\nfor index, row in lineage_df.iterrows():\n lineage = columns[row].values\n if len(lineage) < 1:\n lineage = \"unk\"\n else:\n lineage = lineage[0]\n lineages.append(lineage)\nlineage_series = pd.Series(index=lineage_df.index, data=lineages)\nlineage_series = lineage_series[lineage_series.index.isin(meta.index)]\nmeta[\"lineage\"] = \"unk\"\nmeta.loc[lineage_series.index, \"lineage\"] = lineage_series.values\n\n# %% [markdown]\n# ##\n\npair_meta = meta[meta[\"Pair\"] != -1]\npair_meta = pair_meta.sort_values([\"Pair ID\", \"hemisphere\"])\n\npair_unk = 0\nunk = []\npair_mismatch = 0\nmismatch = []\nfor p in pair_meta[\"Pair ID\"].unique():\n pm = pair_meta[pair_meta[\"Pair ID\"] == p]\n uni_lin = pm[\"lineage\"].unique()\n if (\"unk\" in uni_lin) and len(uni_lin) > 1:\n print(str(uni_lin) + \" unk\")\n pair_unk += 1\n unk.append(pm.index.values)\n elif len(uni_lin) > 1:\n print(str(uni_lin) + \" mismatch\")\n pair_mismatch += 1\n mismatch.append(pm.index.values)\n\nfrom src.io import savecsv\n\nmismatch = pd.DataFrame(mismatch)\nsavecsv(mismatch, \"mismatch\")\nunk = pd.DataFrame(unk)\nsavecsv(unk, \"unk\")\n\n#%%\ninput_counts_path = data_path / data_date_graphs / (input_counts_file + \".csv\")\ninput_counts_df = pd.read_csv(input_counts_path, index_col=0)\ncols = input_counts_df.columns.values\ncols = [str(c).strip(\" \") for c in cols]\ninput_counts_df.columns = cols\n\nmeta.loc[input_counts_df.index, \"dendrite_input\"] = input_counts_df[\"dendrite_inputs\"]\nmeta.loc[input_counts_df.index, \"axon_input\"] = input_counts_df[\"axon_inputs\"]\n\n\n#%% Import the raw graphs\nprint(\"Importing raw adjacency matrices:\\n\")\nnx_graphs_raw = {}\ndf_graphs_raw = {}\nfor graph_type in graph_types:\n print(graph_type)\n edgelist_path = data_path / data_date_graphs / (graph_type + \".csv\")\n adj = pd.read_csv(edgelist_path, index_col=0)\n meta = meta.reindex(adj.index)\n meta_data_dict = meta.to_dict(orient=\"index\")\n graph = df_to_nx(adj, meta_data_dict)\n nx_graphs_raw[graph_type] = graph\n df_graphs_raw[graph_type] = adj\n print()\n\n\n#%% Normalize weights for the raw graphs\ndf_graphs_norm = {}\nnx_graphs_norm = {}\nprint(\"Checking normalized weights\")\ninput_counts = input_counts_df[\"axon_inputs\"].values\n\ninput_counts[input_counts == 0] = 1\nfor graph_type in [\"axon-axon\", \"dendrite-axon\"]:\n print(graph_type)\n df_adj_raw = df_graphs_raw[graph_type]\n if (input_counts_df.index.values == adj.index.values).all():\n print(\"Same indexing!\")\n else:\n raise ValueError(\"Indexing of input counts file not the same!\")\n adj_raw = df_adj_raw.values\n adj_norm = adj_raw / input_counts[np.newaxis, :]\n print(adj_norm.sum(axis=0).max())\n df_adj_norm = pd.DataFrame(\n index=df_adj_raw.index, columns=df_adj_raw.columns, data=adj_norm\n )\n df_graphs_norm[graph_type] = df_adj_norm\n graph = df_to_nx(df_adj_norm, meta_data_dict)\n nx_graphs_norm[graph_type] = graph\n print()\n\ninput_counts = input_counts_df[\"dendrite_inputs\"].values\ninput_counts[input_counts == 0] = 1\nfor graph_type in [\"axon-dendrite\", \"dendrite-dendrite\"]:\n print(graph_type)\n df_adj_raw = df_graphs_raw[graph_type]\n if (input_counts_df.index.values == adj.index.values).all():\n print(\"Same indexing!\")\n adj_raw = df_adj_raw.values\n adj_norm = adj_raw / input_counts[np.newaxis, :]\n print(adj_norm.sum(axis=0).max())\n df_adj_norm = pd.DataFrame(\n index=df_adj_raw.index, columns=df_adj_raw.columns, data=adj_norm\n )\n df_graphs_norm[graph_type] = df_adj_norm\n graph = df_to_nx(df_adj_norm, meta_data_dict)\n nx_graphs_norm[graph_type] = graph\n print()\n\n#%%\n\nprint(\"\\n\\nChecking for rows with Nan values\")\nmissing_na = []\nnan_df = meta[meta.isna().any(axis=1)]\nfor row in nan_df.index:\n na_ind = nan_df.loc[row].isna()\n print(nan_df.loc[row][na_ind])\n missing_na.append(row)\nprint()\nprint(\"These skeletons have missing values in the metadata\")\nprint(missing_na)\nprint(\"\\n\\n\")\n\n\n#%% All-all graph\ntotal_input = (\n input_counts_df[\"dendrite_inputs\"].values + input_counts_df[\"axon_inputs\"].values\n)\ntotal_input[total_input == 0] = 1\n\nall_adj_raw = np.zeros_like(adj_norm)\nfor graph_type in graph_types:\n all_adj_raw += df_graphs_raw[graph_type].values\n\ndf_all_raw = pd.DataFrame(\n index=df_adj_raw.index, columns=df_adj_raw.columns, data=all_adj_raw\n)\n\nnx_all_raw = df_to_nx(df_all_raw, meta_data_dict)\n\nall_adj_norm = all_adj_raw / total_input[np.newaxis, :]\ndf_all_norm = pd.DataFrame(\n index=df_adj_raw.index, columns=df_adj_raw.columns, data=all_adj_norm\n)\n\nnx_all_norm = df_to_nx(df_all_norm, meta_data_dict)\n\n#%% Save\n\nprint(\"Saving graphs:\\n\")\nout_graphs = []\n[out_graphs.append(i) for i in nx_graphs_raw.values()]\n[print(i) for i in nx_graphs_raw.keys()]\nsave_names = [\"Gaa\", \"Gad\", \"Gda\", \"Gdd\"]\n[out_graphs.append(i) for i in nx_graphs_norm.values()]\n[print(i) for i in nx_graphs_norm.keys()]\nsave_names += [\"Gaan\", \"Gdan\", \"Gadn\", \"Gddn\"]\nout_graphs.append(nx_all_raw)\nsave_names.append(\"G\")\nout_graphs.append(nx_all_norm)\nsave_names.append(\"Gn\")\n\nfor name, graph in zip(save_names, out_graphs):\n nx.write_graphml(graph, output_path / (name + \".graphml\"))\n\nmeta.to_csv(output_path / \"meta_data.csv\")\n\n#%% verify things are right\nprint(\"\\n\\nChecking graphs are the same when saved\")\nprint(output_path)\nfor name, graph_wrote in zip(save_names, out_graphs):\n print(name)\n graph_read = nx.read_graphml(output_path / (name + \".graphml\"))\n adj_read = nx.to_numpy_array(graph_read)\n adj_wrote = nx.to_numpy_array(graph_wrote)\n print(np.array_equal(adj_read, adj_wrote))\n graph_loader = load_networkx(name, version=output_name)\n adj_loader = nx.to_numpy_array(graph_loader)\n print(np.array_equal(adj_wrote, adj_loader))\n print()\n\nprint(\"Done!\")\nsys.stdout.close()\n",
"from __future__ import division\nfrom textwrap import dedent\nimport colorsys\nimport numpy as np\nfrom scipy import stats\nimport pandas as pd\nimport matplotlib as mpl\nfrom matplotlib.collections import PatchCollection\nimport matplotlib.patches as Patches\nimport matplotlib.pyplot as plt\nimport warnings\nfrom six import string_types\nfrom six.moves import range\n\nfrom seaborn import utils\nfrom seaborn.axisgrid import FacetGrid\nfrom seaborn.categorical import _BarPlotter, _CategoricalPlotter\nfrom seaborn.categorical import factorplot as _factorplot\n\n\n__all__ = [\"countplot\", \"factorplot\", \"freqplot\"]\n\n\nclass _StackBarPlotter(_BarPlotter):\n \"\"\" Stacked Bar Plotter\n \n A modification of the :mod:`seaborn._BarPlotter` object with the added ability of\n stacking bars either verticaly or horizontally. It takes the same arguments\n as :mod:`seaborn._BarPlotter` plus the following:\n \n Arguments\n ---------\n stack : bool\n Stack bars if true, otherwise returns equivalent barplot as\n :mod:`seaborn._BarPlotter`.\n \"\"\"\n\n def draw_bars(self, ax, kws):\n \"\"\"Draw the bars onto `ax`.\"\"\"\n # Get the right matplotlib function depending on the orientation\n barfunc = ax.bar if self.orient == \"v\" else ax.barh\n barpos = np.arange(len(self.statistic))\n\n if self.plot_hues is None:\n\n # Draw the bars\n barfunc(\n barpos,\n self.statistic,\n self.width,\n color=self.colors,\n align=\"center\",\n **kws,\n )\n\n # Draw the confidence intervals\n errcolors = [self.errcolor] * len(barpos)\n self.draw_confints(\n ax, barpos, self.confint, errcolors, self.errwidth, self.capsize\n )\n else:\n # Stack by hue\n for j, hue_level in enumerate(self.hue_names):\n\n barpos_prior = None if j == 0 else np.sum(self.statistic[:, :j], axis=1)\n\n # Draw the bars\n if self.orient == \"v\":\n barfunc(\n barpos,\n self.statistic[:, j],\n self.nested_width,\n bottom=barpos_prior,\n color=self.colors[j],\n align=\"center\",\n label=hue_level,\n **kws,\n )\n elif self.orient == \"h\":\n barfunc(\n barpos,\n self.statistic[:, j],\n self.nested_width,\n left=barpos_prior,\n color=self.colors[j],\n align=\"center\",\n label=hue_level,\n **kws,\n )\n\n # Draw the confidence intervals\n if self.confint.size:\n confint = (\n self.confint[:, j]\n if j == 0\n else np.sum(self.confint[:, :j], axis=1)\n )\n errcolors = [self.errcolor] * len(barpos)\n self.draw_confints(\n ax, barpos, confint, errcolors, self.errwidth, self.capsize\n )\n\n\ndef countplot(\n x=None,\n y=None,\n hue=None,\n data=None,\n order=None,\n hue_order=None,\n orient=None,\n color=None,\n palette=None,\n saturation=0.75,\n dodge=True,\n stack=False,\n ax=None,\n **kwargs,\n):\n \"\"\" Show the count of observations in each categorical bin using bars.\n \n The count plot is a normalization of a histogram across categories, as opposed\n to quantitative variables. The basic API and options are identical to those for\n :func:`barplot`, so you can compare counts across nested variables.\n \n Parameters\n ----------\n x, y, hue : str or array-like, optional\n Inputs for plotting long-form data.\n data : DataFrame, array, or list of arrays, optional\n Dataset for plotting. If `x` and `y` are absent, this is interpreted as wide-form.\n Otherwise, data is expected to be long-form.\n order, hue_order : list of str, optional\n Order to plot the categorical levels, otherwise the levels are inferred from the\n data object.\n orient : {\"v\", \"h\"}, optional\n Whether to plot bars vertically (\"v\") or horizontally (\"h\"). This can also be\n inferred from the dtype of the input variables, but can be used to specify when the\n \"categorical\" variable is a numeric or when plotting wide-form data.\n color : matplotlib color, optional\n Color for all of the elemnts, or seed for a gradient palette.\n palette : palette name, list, or dict, optional\n Colors to use for the different levels of the `hue` variable. Should be somthing that\n can be interpreted by `color_palette()` or a dictionary mapping hue levels to\n matplotlib colors.\n saturation : float, optional\n Proportion of the original saturation to draw colors. Large patches often look better\n with slighlty desaturated colors, but set this to `1` if you want the plot colorss to\n perfectly match the input color spec.\n dodge : bool, optional\n When hue nesting is used, whether elements should be shifted along the categorical axis.\n stack : bool, optional\n When hue nesting is used, whether elements should be stacked ontop of each other. Note,\n dodge is set to False when stack is True.\n ax : matplotlib.axes, optional\n Axes object to draw the plot onto, otherwise uses the current axes.\n **kwargs : Other keyword arguments are passed through to `plt.bar` at draw time\n \n Examples\n --------\n .. plot::\n :context: close-figs\n \n >>> import schmeaborn as sns\n >>> titanic = sns.load_dataset(\"titanic\")\n >>> ax = sns.freqplot(x=\"class\", data=titanic)\n \n Show frequencies for two categorical variables:\n \n .. plot::\n :context: close-figs\n \n >>> ax = sns.freqplot(x=\"class\", hue=\"who\", data=titanic)\n \n Plot the bars horizontally:\n \n .. plot::\n :context: close-figs\n \n >>> ax = sns.freqplot(y=\"class\", hue=\"who\", data=titanic)\n \n Plot categories stacked:\n \n .. plot::\n :context: close-figs\n \n >>> ax = sns.freqplot(x=\"class\", hue=\"who\", stack=True, data=titanic)\n \"\"\"\n\n # Define parameters for barplot\n if stack:\n dodge = False\n estimator = len\n ci = None\n n_boot = 0\n units = None\n errcolor = None\n errwidth = None\n capsize = None\n\n # Check orientation by input\n if x is None and y is not None:\n orient = \"h\"\n x = y\n elif y is None and x is not None:\n orient = \"v\"\n y = x\n elif x is not None and y is not None:\n raise TypeError(\"Cannot pass values for both `x` and `y`\")\n else:\n raise TypeError(\"Must pass values for either `x` or `y`\")\n\n bar_plot_func = _StackBarPlotter if stack else _BarPlotter\n plotter = bar_plot_func(\n x,\n y,\n hue,\n data,\n order,\n hue_order,\n estimator,\n ci,\n n_boot,\n units,\n orient,\n color,\n palette,\n saturation,\n errcolor,\n errwidth,\n capsize,\n dodge,\n )\n\n plotter.value_label = \"count\"\n\n if ax is None:\n ax = plt.gca()\n\n plotter.plot(ax, kwargs)\n return ax\n\n\ndef freqplot(\n x=None,\n y=None,\n hue=None,\n data=None,\n order=None,\n hue_order=None,\n orient=None,\n color=None,\n palette=None,\n saturation=0.75,\n dodge=True,\n stack=False,\n ax=None,\n **kwargs,\n):\n \"\"\" Show the frequency of observations in each categorical bin using bars.\n \n The frequency plot is a normalization of a histogram across categories, as opposed\n to quantitative variables. The basic API and options are identical to those for\n :func:`barplot`, so you can compare counts across nested variables.\n \n Parameters\n ----------\n x, y, hue : str or array-like, optional\n Inputs for plotting long-form data.\n data : DataFrame, array, or list of arrays, optional\n Dataset for plotting. If `x` and `y` are absent, this is interpreted as wide-form.\n Otherwise, data is expected to be long-form.\n order, hue_order : list of str, optional\n Order to plot the categorical levels, otherwise the levels are inferred from the\n data object.\n orient : {\"v\", \"h\"}, optional\n Whether to plot bars vertically (\"v\") or horizontally (\"h\"). This can also be\n inferred from the dtype of the input variables, but can be used to specify when the\n \"categorical\" variable is a numeric or when plotting wide-form data.\n color : matplotlib color, optional\n Color for all of the elemnts, or seed for a gradient palette.\n palette : palette name, list, or dict, optional\n Colors to use for the different levels of the `hue` variable. Should be somthing that\n can be interpreted by `color_palette()` or a dictionary mapping hue levels to\n matplotlib colors.\n saturation : float, optional\n Proportion of the original saturation to draw colors. Large patches often look better\n with slighlty desaturated colors, but set this to `1` if you want the plot colorss to\n perfectly match the input color spec.\n dodge : bool, optional\n When hue nesting is used, whether elements should be shifted along the categorical axis.\n stack : bool, optional\n When hue nesting is used, whether elements should be stacked ontop of each other. Note,\n dodge is set to False when stack is True.\n ax : matplotlib.axes, optional\n Axes object to draw the plot onto, otherwise uses the current axes.\n **kwargs : Other keyword arguments are passed through to `plt.bar` at draw time\n \n Examples\n --------\n .. plot::\n :context: close-figs\n \n >>> import schmeaborn as sns\n >>> titanic = sns.load_dataset(\"titanic\")\n >>> ax = sns.freqplot(x=\"class\", data=titanic)\n \n Show frequencies for two categorical variables:\n \n .. plot::\n :context: close-figs\n \n >>> ax = sns.freqplot(x=\"class\", hue=\"who\", data=titanic)\n \n Plot the bars horizontally:\n \n .. plot::\n :context: close-figs\n \n >>> ax = sns.freqplot(y=\"class\", hue=\"who\", data=titanic)\n \n Plot categories stacked:\n \n .. plot::\n :context: close-figs\n \n >>> ax = sns.freqplot(x=\"class\", hue=\"who\", stack=True, data=titanic)\n \"\"\"\n\n # Define parameters for barplot\n if stack:\n dodge = False\n estimator = len\n ci = None\n n_boot = 0\n units = None\n errcolor = None\n errwidth = None\n capsize = None\n\n # Check orientation by input\n if x is None and y is not None:\n orient = \"h\"\n x = y\n elif y is None and x is not None:\n orient = \"v\"\n y = x\n elif x is not None and y is not None:\n raise TypeError(\"Cannot pass values for both `x` and `y`\")\n else:\n raise TypeError(\"Must pass values for either `x` or `y`\")\n\n bar_plot_func = _StackBarPlotter if stack else _BarPlotter\n plotter = bar_plot_func(\n x,\n y,\n hue,\n data,\n order,\n hue_order,\n estimator,\n ci,\n n_boot,\n units,\n orient,\n color,\n palette,\n saturation,\n errcolor,\n errwidth,\n capsize,\n dodge,\n )\n\n # Safely calculate frequencies: NaN counts replaced by 0\n plotter.statistic = np.nan_to_num(plotter.statistic)\n\n if plotter.statistic.ndim == 1:\n # Normalize statistic\n plotter.statistic = plotter.statistic / np.nansum(plotter.statistic)\n\n # Safety Check for proper normalization\n err = f\"Frequencies not properly normalized. \\n {plotter.statistic} \\n\"\n assert np.allclose(np.nansum(plotter.statistic), 1, rtol=1e-6), err\n elif plotter.statistic.ndim > 1:\n # Normalize row-stochastic\n plotter.statistic = (\n plotter.statistic / np.nansum(plotter.statistic, axis=1)[:, None]\n )\n\n # Safely check for proper normalization (ignore where full row is null)\n sum_stats = np.nansum(plotter.statistic, axis=1)\n\n # Safety Check for proper normalization\n err = f\"Frequencies not properly normalized. \\n {plotter.statistic} \\n\"\n assert np.allclose(sum_stats, 1, rtol=1e-6), err\n else:\n raise ValueError(\"Unable to count the combination of x and hue.\")\n\n plotter.value_label = \"frequency\"\n\n if ax is None:\n ax = plt.gca()\n\n plotter.plot(ax, kwargs)\n return ax\n",
"from os.path import basename\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nfrom sacred import Experiment\nfrom sacred.observers import FileStorageObserver, SlackObserver\nfrom sklearn.model_selection import ParameterGrid\n\nfrom graspy.datasets import load_drosophila_left\nfrom graspy.utils import binarize, symmetrize\nfrom src.models import select_rdpg, select_sbm, select_dcsbm\nfrom src.utils import save_obj\n\nex = Experiment(\"Drosophila model selection 6 - new, DCSBM\")\n\ncurrent_file = basename(__file__)[:-3]\n\nsacred_file_path = Path(f\"./maggot_models/models/runs/{current_file}\")\n\nslack_obs = SlackObserver.from_config(\"slack.json\")\n\nfile_obs = FileStorageObserver.create(sacred_file_path)\n\nex.observers.append(slack_obs)\nex.observers.append(file_obs)\n\n\[email protected]\ndef config():\n # Variables defined in config get automatically passed to main\n\n n_block_try_range = list(range(1, 11)) # noqa: F841\n n_components_try_range = list(range(1, 13)) # noqa: F841\n n_components_try_rdpg = list(range(1, 13)) # noqa: F841\n reg_try_range = np.linspace(0, 10, 10)\n\n embed_kws_try_range = [{\"regularizer\": i} for i in reg_try_range] # noqa: F841\n n_init = 50 # 50 # noqa: F841\n n_jobs = -1 # noqa: F841\n directed = True # noqa: F841\n\n\ndef run_fit(\n seed,\n n_components_try_range,\n n_components_try_rdpg,\n n_block_try_range,\n directed,\n n_init,\n embed_kws_try_range,\n n_jobs,\n):\n graph = load_drosophila_left()\n if not directed:\n graph = symmetrize(graph, method=\"avg\")\n graph = binarize(graph)\n\n np.random.seed(seed)\n\n param_grid = {\n \"n_components\": n_components_try_range,\n \"n_blocks\": n_block_try_range,\n \"embed_kws\": embed_kws_try_range,\n }\n out_df = select_dcsbm(\n graph,\n param_grid,\n directed=directed,\n degree_directed=False,\n n_jobs=n_jobs,\n n_init=n_init,\n )\n\n print(out_df.head())\n\n save_obj(out_df, file_obs, \"grid_search_out\")\n return 0\n\n\[email protected]\ndef main(\n n_components_try_range,\n n_components_try_rdpg,\n n_block_try_range,\n directed,\n n_init,\n embed_kws_try_range,\n n_jobs,\n):\n seed = 8888\n out = run_fit(\n seed,\n n_components_try_range,\n n_components_try_rdpg,\n n_block_try_range,\n directed,\n n_init,\n embed_kws_try_range,\n n_jobs,\n )\n return out\n"
] | [
[
"matplotlib.cm.ScalarMappable",
"numpy.median",
"numpy.mean",
"numpy.where",
"numpy.concatenate",
"numpy.count_nonzero",
"pandas.DataFrame",
"sklearn.metrics.adjusted_rand_score",
"matplotlib.pyplot.tight_layout",
"numpy.sqrt",
"numpy.zeros",
"numpy.ix_",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.style.use",
"numpy.argsort",
"matplotlib.colors.LogNorm",
"numpy.isinf",
"numpy.errstate",
"numpy.random.seed",
"numpy.sum",
"numpy.diag",
"numpy.unique"
],
[
"numpy.concatenate",
"numpy.full",
"numpy.array",
"numpy.isnan",
"numpy.vectorize",
"numpy.random.seed",
"pandas.DataFrame",
"matplotlib.pyplot.subplots",
"numpy.power",
"pandas.concat",
"numpy.repeat",
"numpy.log10",
"pandas.Series",
"sklearn.decomposition.PCA"
],
[
"numpy.where",
"matplotlib.pyplot.figure"
],
[
"numpy.quantile",
"matplotlib.patches.Ellipse",
"numpy.concatenate",
"numpy.linalg.norm",
"matplotlib.ticker.MaxNLocator",
"numpy.vectorize",
"pandas.DataFrame",
"numpy.linalg.eigh",
"matplotlib.pyplot.subplots",
"numpy.logical_and",
"numpy.eye",
"matplotlib.pyplot.tight_layout",
"numpy.sqrt",
"sklearn.metrics.adjusted_rand_score",
"numpy.log10",
"matplotlib.ticker.MultipleLocator",
"matplotlib.pyplot.close",
"numpy.ix_",
"scipy.optimize.linear_sum_assignment",
"numpy.arctan2",
"scipy.linalg.orthogonal_procrustes",
"numpy.random.seed",
"numpy.sum",
"numpy.diag",
"numpy.unique"
],
[
"matplotlib.pyplot.twinx",
"numpy.union1d",
"numpy.vectorize",
"numpy.median",
"pandas.DataFrame",
"matplotlib.pyplot.suptitle",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.MaxNLocator",
"matplotlib.pyplot.subplots",
"numpy.linspace",
"matplotlib.pyplot.figure",
"numpy.where",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.style.use",
"matplotlib.pyplot.subplot2grid",
"pandas.read_csv",
"numpy.unique"
],
[
"numpy.quantile",
"sklearn.cluster.AgglomerativeClustering",
"numpy.random.seed",
"matplotlib.pyplot.subplots",
"numpy.log10"
],
[
"numpy.concatenate",
"numpy.array",
"numpy.zeros_like",
"numpy.array_equal",
"numpy.vectorize",
"pandas.DataFrame",
"numpy.where",
"pandas.concat",
"pandas.read_csv",
"pandas.Series",
"numpy.unique",
"numpy.isin"
],
[
"numpy.nan_to_num",
"numpy.sum",
"numpy.nansum",
"numpy.allclose",
"matplotlib.pyplot.gca"
],
[
"numpy.random.seed",
"numpy.linspace"
]
] |
theoptips/PySyft | [
"4b68c3c6fbe0c18cdf87dfe6ddc3c2071a71f1cc",
"4b68c3c6fbe0c18cdf87dfe6ddc3c2071a71f1cc"
] | [
"examples/tutorials/advanced/websockets-example-MNIST-parallel/run_websocket_client.py",
"syft/federated/federated_client.py"
] | [
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchvision import transforms, datasets\n\nimport logging\nimport argparse\nimport sys\nimport asyncio\nimport numpy as np\n\nimport syft as sy\nfrom syft import workers\nfrom syft.frameworks.torch.federated import utils\n\nlogger = logging.getLogger(__name__)\n\nLOG_INTERVAL = 25\n\n\n# Loss function\[email protected]\ndef loss_fn(pred, target):\n return F.nll_loss(input=pred, target=target)\n\n\n# Model\nclass Net(nn.Module):\n def __init__(self):\n super(Net, self).__init__()\n self.conv1 = nn.Conv2d(1, 20, 5, 1)\n self.conv2 = nn.Conv2d(20, 50, 5, 1)\n self.fc1 = nn.Linear(4 * 4 * 50, 500)\n self.fc2 = nn.Linear(500, 10)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n x = F.max_pool2d(x, 2, 2)\n x = F.relu(self.conv2(x))\n x = F.max_pool2d(x, 2, 2)\n x = x.view(-1, 4 * 4 * 50)\n x = F.relu(self.fc1(x))\n x = self.fc2(x)\n return F.log_softmax(x, dim=1)\n\n\ndef define_and_get_arguments(args=sys.argv[1:]):\n parser = argparse.ArgumentParser(\n description=\"Run federated learning using websocket client workers.\"\n )\n parser.add_argument(\"--batch_size\", type=int, default=32, help=\"batch size of the training\")\n parser.add_argument(\n \"--test_batch_size\", type=int, default=128, help=\"batch size used for the test data\"\n )\n parser.add_argument(\n \"--training_rounds\", type=int, default=40, help=\"number of federated learning rounds\"\n )\n parser.add_argument(\n \"--federate_after_n_batches\",\n type=int,\n default=10,\n help=\"number of training steps performed on each remote worker before averaging\",\n )\n parser.add_argument(\"--lr\", type=float, default=0.1, help=\"learning rate\")\n parser.add_argument(\"--cuda\", action=\"store_true\", help=\"use cuda\")\n parser.add_argument(\"--seed\", type=int, default=1, help=\"seed used for randomization\")\n parser.add_argument(\"--save_model\", action=\"store_true\", help=\"if set, model will be saved\")\n parser.add_argument(\n \"--verbose\",\n \"-v\",\n action=\"store_true\",\n help=\"if set, websocket client workers will be started in verbose mode\",\n )\n\n args = parser.parse_args(args=args)\n return args\n\n\nasync def fit_model_on_worker(\n worker: workers.WebsocketClientWorker,\n traced_model: torch.jit.ScriptModule,\n batch_size: int,\n curr_round: int,\n max_nr_batches: int,\n lr: float,\n):\n \"\"\"Send the model to the worker and fit the model on the worker's training data.\n\n Args:\n worker: Remote location, where the model shall be trained.\n traced_model: Model which shall be trained.\n batch_size: Batch size of each training step.\n curr_round: Index of the current training round (for logging purposes).\n max_nr_batches: If > 0, training on worker will stop at min(max_nr_batches, nr_available_batches).\n lr: Learning rate of each training step.\n\n Returns:\n A tuple containing:\n * worker_id: Union[int, str], id of the worker.\n * improved model: torch.jit.ScriptModule, model after training at the worker.\n * loss: Loss on last training batch, torch.tensor.\n \"\"\"\n train_config = sy.TrainConfig(\n model=traced_model,\n loss_fn=loss_fn,\n batch_size=batch_size,\n shuffle=True,\n max_nr_batches=max_nr_batches,\n epochs=1,\n lr=lr,\n )\n train_config.send(worker)\n logger.info(\n \"Training round %s, calling fit on worker: %s, lr = %s\",\n curr_round,\n worker.id,\n \"{:.3f}\".format(train_config.lr),\n )\n loss = await worker.async_fit(dataset_key=\"mnist\", return_ids=[0])\n logger.info(\"Training round: %s, worker: %s, avg_loss: %s\", curr_round, worker.id, loss.mean())\n model = train_config.model_ptr.get().obj\n return worker.id, model, loss\n\n\ndef evaluate_models_on_test_data(test_loader, results):\n np.set_printoptions(formatter={\"float\": \"{: .0f}\".format})\n for worker_id, worker_model, _ in results:\n evaluate_model(worker_id, worker_model, \"cpu\", test_loader, print_target_hist=False)\n\n\ndef evaluate_model(worker_id, model, device, test_loader, print_target_hist=False):\n model.eval()\n test_loss = 0.0\n correct = 0\n hist_target = np.zeros(10)\n hist_pred = np.zeros(10)\n\n with torch.no_grad():\n for data, target in test_loader:\n data, target = data.to(device), target.to(device)\n hist, _ = np.histogram(target, bins=10, range=(0, 10))\n hist_target += hist\n output = model(data)\n test_loss += loss_fn(output, target).item() # sum up batch loss\n pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability\n hist, _ = np.histogram(pred, bins=10, range=(0, 10))\n hist_pred += hist\n correct += pred.eq(target.view_as(pred)).sum().item()\n\n test_loss /= len(test_loader.dataset)\n\n if print_target_hist:\n logger.info(\"Target histogram: %s\", hist_target)\n logger.info(\"Prediction hist.: %s\", hist_pred)\n\n logger.info(\n \"%s: Test set: Average loss: %s, Accuracy: %s/%s (%s)\",\n worker_id,\n \"{:.4f}\".format(test_loss),\n correct,\n len(test_loader.dataset),\n \"{:.2f}\".format(100.0 * correct / len(test_loader.dataset)),\n )\n\n\nasync def main():\n args = define_and_get_arguments()\n\n hook = sy.TorchHook(torch)\n\n kwargs_websocket = {\"host\": \"localhost\", \"hook\": hook, \"verbose\": args.verbose}\n alice = workers.WebsocketClientWorker(id=\"alice\", port=8777, **kwargs_websocket)\n bob = workers.WebsocketClientWorker(id=\"bob\", port=8778, **kwargs_websocket)\n charlie = workers.WebsocketClientWorker(id=\"charlie\", port=8779, **kwargs_websocket)\n\n worker_instances = [alice, bob, charlie]\n\n use_cuda = args.cuda and torch.cuda.is_available()\n\n torch.manual_seed(args.seed)\n\n device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n\n kwargs = {\"num_workers\": 1, \"pin_memory\": True} if use_cuda else {}\n\n test_loader = torch.utils.data.DataLoader(\n datasets.MNIST(\n \"../data\",\n train=False,\n transform=transforms.Compose(\n [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]\n ),\n ),\n batch_size=args.test_batch_size,\n shuffle=False,\n drop_last=False,\n **kwargs,\n )\n\n model = Net().to(device)\n\n (data, target) = test_loader.__iter__().next()\n traced_model = torch.jit.trace(model, data)\n learning_rate = args.lr\n\n for curr_round in range(1, args.training_rounds + 1):\n logger.info(\"Starting training round %s/%s\", curr_round, args.training_rounds)\n\n results = await asyncio.gather(\n *[\n fit_model_on_worker(\n worker=worker,\n traced_model=traced_model,\n batch_size=args.batch_size,\n curr_round=curr_round,\n max_nr_batches=args.federate_after_n_batches,\n lr=learning_rate,\n )\n for worker in worker_instances\n ]\n )\n models = {}\n loss_values = {}\n\n test_models = curr_round % 10 == 1 or curr_round == args.training_rounds\n if test_models:\n evaluate_models_on_test_data(test_loader, results)\n\n for worker_id, worker_model, worker_loss in results:\n if worker_model is not None:\n models[worker_id] = worker_model\n loss_values[worker_id] = worker_loss\n\n traced_model = utils.federated_avg(models)\n if test_models:\n evaluate_model(\n \"Federated model\", traced_model, \"cpu\", test_loader, print_target_hist=True\n )\n\n # decay learning rate\n learning_rate = max(0.98 * learning_rate, args.lr * 0.01)\n\n if args.save_model:\n torch.save(model.state_dict(), \"mnist_cnn.pt\")\n\n\nif __name__ == \"__main__\":\n # Logging setup\n logger = logging.getLogger(\"run_websocket_server\")\n FORMAT = \"%(asctime)s %(levelname)s %(filename)s(l:%(lineno)d, p:%(process)d) - %(message)s\"\n logging.basicConfig(format=FORMAT)\n logger.setLevel(level=logging.DEBUG)\n\n # Websockets setup\n websockets_logger = logging.getLogger(\"websockets\")\n websockets_logger.setLevel(logging.INFO)\n websockets_logger.addHandler(logging.StreamHandler())\n\n # Run main\n asyncio.get_event_loop().run_until_complete(main())\n",
"import torch as th\nfrom torch.utils.data import BatchSampler, RandomSampler, SequentialSampler\n\nfrom syft.generic import ObjectStorage\nfrom syft.federated.train_config import TrainConfig\n\n\nclass FederatedClient(ObjectStorage):\n \"\"\"A Client able to execute federated learning in local datasets.\"\"\"\n\n def __init__(self, datasets=None):\n super().__init__()\n self.datasets = datasets if datasets is not None else dict()\n self.optimizer = None\n self.train_config = None\n\n def add_dataset(self, dataset, key: str):\n self.datasets[key] = dataset\n\n def remove_dataset(self, key: str):\n if key in self.datasets:\n del self.datasets[key]\n\n def set_obj(self, obj: object):\n \"\"\"Registers objects checking if which objects it should cache.\n\n Args:\n obj: An object to be registered.\n \"\"\"\n if isinstance(obj, TrainConfig):\n self.train_config = obj\n self.optimizer = None\n else:\n super().set_obj(obj)\n\n def _build_optimizer(\n self, optimizer_name: str, model, optimizer_args: dict\n ) -> th.optim.Optimizer:\n \"\"\"Build an optimizer if needed.\n\n Args:\n optimizer_name: A string indicating the optimizer name.\n optimizer_args: A dict containing the args used to initialize the optimizer.\n Returns:\n A Torch Optimizer.\n \"\"\"\n if self.optimizer is not None:\n return self.optimizer\n\n if optimizer_name in dir(th.optim):\n optimizer = getattr(th.optim, optimizer_name)\n self.optimizer = optimizer(model.parameters(), **optimizer_args)\n else:\n raise ValueError(\"Unknown optimizer: {}\".format(optimizer_name))\n return self.optimizer\n\n def fit(self, dataset_key: str, **kwargs):\n \"\"\"Fits a model on the local dataset as specified in the local TrainConfig object.\n\n Args:\n dataset_key: Identifier of the local dataset that shall be used for training.\n **kwargs: Unused.\n\n Returns:\n loss: Training loss on the last batch of training data.\n \"\"\"\n if self.train_config is None:\n raise ValueError(\"TrainConfig not defined.\")\n\n if dataset_key not in self.datasets:\n raise ValueError(\"Dataset {} unknown.\".format(dataset_key))\n\n model = self.get_obj(self.train_config._model_id).obj\n loss_fn = self.get_obj(self.train_config._loss_fn_id).obj\n\n self._build_optimizer(\n self.train_config.optimizer, model, optimizer_args=self.train_config.optimizer_args\n )\n\n return self._fit(model=model, dataset_key=dataset_key, loss_fn=loss_fn)\n\n def _create_data_loader(self, dataset_key: str, shuffle: bool = False):\n data_range = range(len(self.datasets[dataset_key]))\n if shuffle:\n sampler = RandomSampler(data_range)\n else:\n sampler = SequentialSampler(data_range)\n data_loader = th.utils.data.DataLoader(\n self.datasets[dataset_key],\n batch_size=self.train_config.batch_size,\n sampler=sampler,\n num_workers=0,\n )\n return data_loader\n\n def _fit(self, model, dataset_key, loss_fn):\n model.train()\n data_loader = self._create_data_loader(\n dataset_key=dataset_key, shuffle=self.train_config.shuffle\n )\n\n loss = None\n iteration_count = 0\n\n for _ in range(self.train_config.epochs):\n for (data, target) in data_loader:\n # Set gradients to zero\n self.optimizer.zero_grad()\n\n # Update model\n output = model(data)\n loss = loss_fn(target=target, pred=output)\n loss.backward()\n self.optimizer.step()\n\n # Update and check interation count\n iteration_count += 1\n if iteration_count >= self.train_config.max_nr_batches >= 0:\n break\n\n return loss\n"
] | [
[
"torch.nn.Linear",
"torch.device",
"numpy.histogram",
"numpy.zeros",
"numpy.set_printoptions",
"torch.no_grad",
"torch.nn.functional.log_softmax",
"torch.manual_seed",
"torch.nn.Conv2d",
"torch.cuda.is_available",
"torch.jit.trace",
"torch.nn.functional.nll_loss",
"torch.nn.functional.max_pool2d"
],
[
"torch.utils.data.SequentialSampler",
"torch.utils.data.RandomSampler",
"torch.utils.data.DataLoader"
]
] |
Ali-ry/azureml-examples | [
"817ae89d2766dcafd70937a22cb3a80f100a2906"
] | [
"python-sdk/tutorials/automl-with-azureml/forecasting-recipes-univariate/forecasting_script.py"
] | [
"\"\"\"\r\nThis is the script that is executed on the compute instance. It relies\r\non the model.pkl file which is uploaded along with this script to the\r\ncompute instance.\r\n\"\"\"\r\n\r\nimport argparse\r\nfrom azureml.core import Dataset, Run\r\nfrom azureml.automl.core.shared.constants import TimeSeriesInternal\r\nfrom sklearn.externals import joblib\r\n\r\nparser = argparse.ArgumentParser()\r\nparser.add_argument(\r\n \"--target_column_name\",\r\n type=str,\r\n dest=\"target_column_name\",\r\n help=\"Target Column Name\",\r\n)\r\nparser.add_argument(\r\n \"--test_dataset\", type=str, dest=\"test_dataset\", help=\"Test Dataset\"\r\n)\r\n\r\nargs = parser.parse_args()\r\ntarget_column_name = args.target_column_name\r\ntest_dataset_id = args.test_dataset\r\n\r\nrun = Run.get_context()\r\nws = run.experiment.workspace\r\n\r\n# get the input dataset by id\r\ntest_dataset = Dataset.get_by_id(ws, id=test_dataset_id)\r\n\r\nX_test = (\r\n test_dataset.drop_columns(columns=[target_column_name])\r\n .to_pandas_dataframe()\r\n .reset_index(drop=True)\r\n)\r\ny_test_df = (\r\n test_dataset.with_timestamp_columns(None)\r\n .keep_columns(columns=[target_column_name])\r\n .to_pandas_dataframe()\r\n)\r\n\r\n# generate forecast\r\nfitted_model = joblib.load(\"model.pkl\")\r\n# We have default quantiles values set as below(95th percentile)\r\nquantiles = [0.025, 0.5, 0.975]\r\npredicted_column_name = \"predicted\"\r\nPI = \"prediction_interval\"\r\nfitted_model.quantiles = quantiles\r\npred_quantiles = fitted_model.forecast_quantiles(X_test)\r\npred_quantiles[PI] = pred_quantiles[[min(quantiles), max(quantiles)]].apply(\r\n lambda x: \"[{}, {}]\".format(x[0], x[1]), axis=1\r\n)\r\nX_test[target_column_name] = y_test_df[target_column_name]\r\nX_test[PI] = pred_quantiles[PI]\r\nX_test[predicted_column_name] = pred_quantiles[0.5]\r\n# drop rows where prediction or actuals are nan\r\n# happens because of missing actuals\r\n# or at edges of time due to lags/rolling windows\r\nclean = X_test[\r\n X_test[[target_column_name, predicted_column_name]].notnull().all(axis=1)\r\n]\r\nclean.rename(columns={target_column_name: \"actual\"}, inplace=True)\r\n\r\nfile_name = \"outputs/predictions.csv\"\r\nexport_csv = clean.to_csv(file_name, header=True, index=False) # added Index\r\n\r\n# Upload the predictions into artifacts\r\nrun.upload_file(name=file_name, path_or_stream=file_name)\r\n"
] | [
[
"sklearn.externals.joblib.load"
]
] |
nielsbril/best | [
"8a902293605f1bee1abf3ca66ae3708706658772"
] | [
"matching/matching.py"
] | [
"import pandas as pd\nimport argparse\nimport logging\nimport sys\nimport json\n\n\ndef get_best_logger(log_file, verbose):\n # Setup logger - (Python logger breaks PEP8 by default)\n logger = logging.getLogger(__name__)\n if verbose:\n logger.setLevel('DEBUG')\n # file_handler logs to file, stream_handler to console\n file_handler = logging.FileHandler(log_file)\n stream_handler = logging.StreamHandler()\n # formatter sets log format\n formatter = logging.Formatter(\n '%(asctime)s - %(name)s : %(levelname)s - %(message)s')\n # add formatter to both handlers\n file_handler.setFormatter(formatter)\n stream_handler.setFormatter(formatter)\n # add both handlers to logger\n logger.addHandler(file_handler)\n logger.addHandler(stream_handler)\n return logger\n\n\ndef compare_addresses(args):\n \"\"\"Compare the addresses of two files\n \"\"\"\n logger.info('Started reading BOSA address file')\n try:\n bosa = pd.read_csv(args.input_file_1)\n logger.info('Read the BOSA address file')\n except IOError as io:\n logger.fatal(io)\n sys.exit(1)\n\n logger.info('Started reading comparison file')\n try:\n comparison = pd.read_csv(args.input_file_2)\n logger.info('Read the comparison file')\n except IOError as io:\n logger.fatal(io)\n sys.exit(1)\n\n comp_keys = []\n bosa_ids = []\n for comp_key, bosa_key in args.mapping.items():\n try:\n comp_keys.append(comp_key)\n bosa_ids.append(bosa.columns.get_loc(bosa_key))\n except KeyError as ke:\n logger.error(\n 'Column %s of column mapping (%s -> %s) not found in BOSA file', ke, comp_key, bosa_key)\n sys.exit(1)\n\n address_dict = {}\n logger.info('Building data structure to perform matching')\n for i, row in enumerate(bosa.values):\n if i % 50_000 == 0:\n logger.info('Processed %i / %i addresses', i, len(bosa))\n address_dict[tuple(el.lower() if type(\n el) == str else el for el in row[bosa_ids])] = row\n\n extended = perform_exact_matching(\n bosa, comparison, address_dict, comp_keys)\n\n try:\n extended.to_csv(args.output_file, index=False)\n except IOError as io:\n logger.fatal(io)\n sys.exit(1)\n\n\ndef perform_exact_matching(bosa, comparison, address_dict, comp_keys):\n \"\"\"Match the addresses in the comparison file and add address_id and coordinates when matched\n \"\"\"\n addr_id = bosa.columns.get_loc('address_id')\n lon_id = bosa.columns.get_loc('EPSG:4326_lon')\n lat_id = bosa.columns.get_loc('EPSG:4326_lat')\n\n extended = []\n logger.info('Performing matching')\n for i, row in comparison.iterrows():\n if i % 50_000 == 0:\n logger.info('Matched %i / %i addresses', i, len(comparison))\n try:\n key = tuple(el.lower() if type(el) ==\n str else el for el in row[comp_keys])\n except KeyError as ke:\n logger.error('Column %s not found in the comparison file', ke)\n sys.exit(1)\n if key in address_dict:\n # If the address is matched add address_id and coordinates to it\n data = address_dict[key]\n row['address_id'] = data[addr_id]\n row['EPSG:4326_lon'] = data[lon_id]\n row['EPSG:4326_lat'] = data[lat_id]\n extended.append(row)\n extended = pd.DataFrame(extended)\n # Convert column to int type that can handle NaN\n extended['address_id'] = extended['address_id'].astype('Int64')\n\n return extended\n\n\nif __name__ == \"__main__\":\n # Setup argument parser\n parser = argparse.ArgumentParser(\n description='Compare addresses between two csv files.')\n parser.add_argument(\n 'input_file_1', help='BOSA address file, in csv format')\n parser.add_argument(\n 'input_file_2', help='Address file to compare to BOSA address file, in csv format')\n parser.add_argument('output_file', help='Name of file to write output to')\n parser.add_argument('--mode', default='exact',\n choices=['exact'], help='How to compare the addresses.')\n parser.add_argument(\n '--mapping', default={}, type=json.loads, help='Column names to consider in the comparison and how they map to the \\\n column names of the BOSA address file. (as a json dict of {comparison_key: bosa_key})')\n parser.add_argument('--log_name', default=\"compare.log\",\n help='name of the log file')\n parser.add_argument('--verbose', action=\"store_true\",\n help=\"toggle verbose output\", default=False)\n\n args = parser.parse_args()\n\n logger = get_best_logger(args.log_name, args.verbose)\n\n compare_addresses(args)\n"
] | [
[
"pandas.DataFrame",
"pandas.read_csv"
]
] |
spyke/spyke | [
"20934521de9c557924911cf6190690ac1c6f8e80",
"20934521de9c557924911cf6190690ac1c6f8e80"
] | [
"spyke/sort.py",
"spyke/core.py"
] | [
"\"\"\"Spike sorting classes and window\"\"\"\n\nfrom __future__ import division\nfrom __future__ import print_function\n\n__authors__ = ['Martin Spacek', 'Reza Lotun']\n\nimport os\nimport sys\nimport time\nimport datetime\nfrom copy import copy\nimport operator\nimport random\nimport shutil\nimport hashlib\nimport multiprocessing as mp\n\nfrom PyQt4 import QtCore, QtGui\nfrom PyQt4.QtCore import Qt\nfrom PyQt4.QtGui import QAction, QIcon, QApplication\n\nimport numpy as np\nimport scipy\nimport scipy.signal\n#from scipy.cluster.hierarchy import fclusterdata\n\nimport pylab as pl\n\nimport pyximport\npyximport.install(build_in_temp=False, inplace=True)\nfrom . import util # .pyx file\n\nfrom . import core\nfrom .core import (WaveForm, Gaussian, MAXLONGLONG, R, toiter, intround, printflush, lstrip,\n rstrip, lrstrip, pad, td2days, SpykeToolWindow, NList, NSList, dist,\n USList, ClusterChange, SpikeSelectionSlider, lrrep2Darrstripis, rollwin2D)\nfrom .detect import DEBUG\nfrom .surf import EPOCH\nfrom .plot import SpikeSortPanel, CLUSTERCOLOURDICT, WHITE\nfrom .__version__ import __version__\n\n#MAXCHANTOLERANCE = 100 # um\n\nNSLISTWIDTH = 70 # minimize nslist width, enough for 7 digit spike IDs\nPANELWIDTHPERCOLUMN = 120 # sort panel width per column of channels\nPANELHEIGHTPERROW = 50 # sort panel height per row of channels\nVSCROLLBARWIDTH = 14 # hack\nSORTWINDOWHEIGHT = 1035 # TODO: this should be set programmatically\nMINSORTWINDOWWIDTH = 566\n\nMEANWAVEMAXSAMPLES = 2000\nNPCSPERCHAN = 7\n\nPCALIB = 'mdp'\nICALIB = 'sklearn'\n\nDEFMINISI = 50 # default minimum ISI to check for on export, us\n\nMAXGROUPISI = 100000 # us (100 ms)\nMAXGROUPDT = 100000000 # us (100 s)\n\n\nclass Sort(object):\n \"\"\"A spike sorting session, in which you can detect spikes and sort them into Neurons.\n A .sort file is a single Python2-pickled Sort object. A .json file is a\n jsonpickle-pickled Sort object\"\"\"\n def __init__(self, detector=None, stream=None, tw=None):\n self.__version__ = __version__\n self.fname = ''\n self.user = ''\n self.notes = ''\n self.detector = detector # this Sort's current Detector object\n self.tw = tw # time window (us) relative to spike time\n self.stream = stream\n self.probe = stream.probe # only one probe design per sort allowed\n self.converter = stream.converter\n self.neurons = {}\n self.clusters = {} # neurons with multidm params scaled for plotting\n self.norder = [] # stores order of neuron ids display in nlist\n self.npcsperchan = NPCSPERCHAN\n\n def get_nextnid(self):\n \"\"\"nextnid is used to retrieve the next unique single unit ID\"\"\"\n nids = list(self.neurons)\n if len(nids) == 0:\n return 1 # single unit nids start at 1\n else:\n return max(max(nids) + 1, 1) # at least 1\n\n nextnid = property(get_nextnid)\n\n def get_nextmuid(self):\n \"\"\"nextmuid is used to retrieve the next unique multiunit ID\"\"\"\n nids = list(self.neurons)\n if len(nids) == 0:\n return -1 # multiunit ids start at -1\n else:\n return min(min(nids) - 1, -1) # at most -1\n\n nextmuid = property(get_nextmuid)\n\n def get_good(self):\n \"\"\"Return array of nids marked by user as 'good'\"\"\"\n good = []\n for neuron in self.neurons.values():\n try:\n if neuron.good:\n good.append(neuron.id)\n except AttributeError: # neuron is from older sort, no .good attrib\n neuron.good = False\n return np.asarray(good)\n\n def set_good(self, good):\n \"\"\"Set good flag to True for nids in good, False otherwise\"\"\"\n nids = list(self.neurons)\n assert np.all([ nid in nids for nid in good ]) # make sure all nids in good exist\n notgood = np.setdiff1d(nids, good)\n for nid in notgood:\n neuron = self.neurons[nid]\n neuron.good = False\n for nid in good:\n neuron = self.neurons[nid]\n neuron.good = True\n\n good = property(get_good, set_good)\n\n def get_stream(self):\n try:\n return self._stream\n except AttributeError:\n # this is likely a brand new sort, has yet to be assigned a Stream\n return None\n\n def set_stream(self, stream=None):\n \"\"\"Check stream type and name and probe type, and restore filtmeth, car, sampfreq and\n shcorrect to stream when binding/modifying stream to self\"\"\"\n oldstream = self.stream\n if stream != None and oldstream != None:\n # do stream types match?\n if type(stream) != type(oldstream):\n raise ValueError(\"Stream types don't match: %s, %s\"\n % (type(oldstream), type(stream)))\n # do stream probe types match?\n if type(stream.probe) != type(oldstream.probe):\n raise ValueError(\"Stream probe types don't match: %s, %s\"\n % (type(oldstream.probe), type(stream.probe)))\n # is one stream fname a superset of the other?\n if (stream.fname not in oldstream.fname) and (oldstream.fname not in stream.fname):\n raise ValueError(\"Stream file names are not supersets of each other: %s, %s\"\n % (oldstream.fname, stream.fname))\n else:\n print('Stream file names are similar enough to proceed: %s, %s'\n % (stream.fname, oldstream.fname))\n try:\n stream.filtmeth = self.filtmeth\n stream.car = self.car\n stream.sampfreq = self.sampfreq\n stream.shcorrect = self.shcorrect\n except AttributeError:\n pass # one of the above aren't bound\n self._stream = stream # set it\n print('Bound stream %r to sort %r' % (stream.fname, self.fname))\n # now that tres is known, calculate window timepoints wrt spike time:\n self.calc_twts_twi()\n\n stream = property(get_stream, set_stream)\n\n def calc_twts_twi(self):\n \"\"\"Calculate temporal window timepoints wrt spike time, and the indices of these\n timepoints wrt spike time\"\"\"\n tres = self.tres\n tw = self.tw\n twts = np.arange(tw[0], tw[1], tres)\n twts += twts[0] % tres # get rid of mod, so twts go through zero\n self.twts = twts\n self.twi = intround(twts[0] / tres), intround(twts[-1] / tres)\n #info('twi = %s' % (self.twi,))\n\n def update_tw(self, tw):\n \"\"\"Update tw and everything that depends on it. Note that this shouldn't\n be called directly by the user. Call SpykeWindow.update_spiketw() instead\"\"\"\n oldtw = self.tw\n self.tw = tw\n self.calc_twts_twi()\n dtw = np.asarray(tw) - np.asarray(oldtw) # new minus old\n self.spikes['t0'] += dtw[0]\n self.spikes['t1'] += dtw[1]\n self.spikes['tis'] = self.spikes['tis'] - intround(dtw[0] / self.tres)\n # recalculate any existing templates:\n for neuron in self.neurons.values():\n if neuron.wave.data != None:\n neuron.update_wave()\n print('WARNING: all spike waveforms need to be reloaded!')\n\n def get_tres(self):\n return self.stream.tres\n\n tres = property(get_tres)\n\n def __getstate__(self):\n \"\"\"Get object state for pickling\"\"\"\n # copy it cuz we'll be making changes, this is fast because it's just a shallow copy\n d = self.__dict__.copy()\n # Spikes and wavedata arrays are (potentially) saved separately.\n # usids and PCs/ICs can be regenerated from the spikes array.\n for attr in ['spikes', 'wavedata', 'usids', 'X', 'Xhash']:\n # keep _stream during normal pickling for multiprocessing, but remove it\n # manually when pickling to sort file\n try: del d[attr]\n except KeyError: pass\n return d\n\n def get_nspikes(self):\n try: return len(self.spikes)\n except AttributeError: return 0\n\n nspikes = property(get_nspikes)\n\n def update_usids(self):\n \"\"\"Update usids, which is an array of indices of unsorted spikes\"\"\"\n nids = self.spikes['nid']\n self.usids, = np.where(nids == 0) # 0 means unclustered\n\n def get_spikes_sortedby(self, attr='id'):\n \"\"\"Return array of all spikes, sorted by attribute 'attr'\"\"\"\n vals = self.spikes[attr]\n spikes = self.spikes[vals.argsort()]\n return spikes\n\n def get_wave(self, sid):\n \"\"\"Return WaveForm corresponding to spike sid\"\"\"\n spikes = self.spikes\n nchans = spikes['nchans'][sid]\n chans = spikes['chans'][sid, :nchans]\n t0 = spikes['t0'][sid]\n t1 = spikes['t1'][sid]\n wavedata = self.wavedata[sid, 0:nchans]\n ts = np.arange(t0, t1, self.tres) # build them up\n return WaveForm(data=wavedata, ts=ts, chans=chans, tres=self.tres)\n\n def get_maxchan_wavedata(self, sid=None, nid=None):\n \"\"\"Return wavedata of maxchan of spike sid or neuron nid\"\"\"\n if sid != None:\n assert nid == None\n chani = self.spikes['chani'][sid]\n return self.wavedata[sid, chani]\n elif nid != None:\n assert sid == None\n neuron = self.neurons[nid]\n chani, = np.where(neuron.chans == neuron.chan)\n assert len(chani) == 1\n chani = chani[0] # pull out of length 1 array\n return neuron.wave.data[chani]\n\n def get_mean_wave(self, sids, nid=None):\n \"\"\"Return the mean and std waveform of spike waveforms in sids\"\"\"\n spikes = self.spikes\n nsids = len(sids)\n if nsids > MEANWAVEMAXSAMPLES:\n step = nsids // MEANWAVEMAXSAMPLES + 1 \n s = (\"get_mean_wave() sampling every %d spikes instead of all %d\"\n % (step, nsids))\n if nid != None:\n s = \"neuron %d: \" % nid + s\n print(s)\n sids = sids[::step]\n nsids = len(sids) # update\n \n chanss = spikes['chans'][sids]\n nchanss = spikes['nchans'][sids]\n chanslist = [ chans[:nchans] for chans, nchans in zip(chanss, nchanss) ] # list of arrays\n chanpopulation = np.concatenate(chanslist)\n groupchans = np.unique(chanpopulation) # comes out sorted\n \n wavedata = self.wavedata[sids]\n if wavedata.ndim == 2: # should be 3, get only 2 if nsids == 1\n wavedata.shape = 1, wavedata.shape[0], wavedata.shape[1] # give it a singleton 3rd dim\n nt = wavedata.shape[-1]\n maxnchans = len(groupchans)\n data = np.zeros((maxnchans, nt))\n # all spikes have same nt, but not necessarily same nchans, keep track of\n # how many spikes contributed to each of the group's chans\n nspikes = np.zeros((maxnchans, 1), dtype=int)\n for chans, wd in zip(chanslist, wavedata):\n chanis = groupchans.searchsorted(chans) # each spike's chans is a subset of groupchans\n data[chanis] += wd[:len(chans)] # accumulate\n nspikes[chanis] += 1 # inc spike count for this spike's chans\n #t0 = time.time()\n data /= nspikes # normalize all data points appropriately, this is now the mean\n var = np.zeros((maxnchans, nt))\n for chans, wd in zip(chanslist, wavedata):\n chanis = groupchans.searchsorted(chans) # each spike's chans is a subset of groupchans\n var[chanis] += (wd[:len(chans)] - data[chanis]) ** 2 # accumulate 2nd moment\n var /= nspikes # normalize all data points appropriately, this is now the variance\n std = np.sqrt(var)\n # keep only those chans that at least 1/2 the spikes contributed to\n bins = list(groupchans) + [np.inf] # concatenate rightmost bin edge\n hist, bins = np.histogram(chanpopulation, bins=bins)\n chans = groupchans[hist >= nsids/2]\n chanis = groupchans.searchsorted(chans)\n data = data[chanis]\n std = std[chanis]\n return WaveForm(data=data, std=std, chans=chans)\n\n def check_ISIs(self, nids='good'):\n \"\"\"Check that interspike intervals of spikes in each nid never fall below DEFMINISI\"\"\"\n print('Checking inter-spike intervals')\n if nids == 'good':\n nids = self.good\n elif nids == 'all':\n nids = sorted(self.neurons)\n for nid in nids:\n neuron = self.neurons[nid]\n spikets = self.spikes['t'][neuron.sids] # should be a sorted copy\n assert spikets.flags['OWNDATA'] # safe to modify in place\n spikets.sort() # just in case it isn't perfectly sorted\n ndupl = (np.diff(spikets) < DEFMINISI).sum()\n if ndupl > 0:\n msg = ('n%d has %d duplicate spikes (given DEFMINISI=%d us).\\n'\n 'Remove duplicate spikes with the ISI tool in the Verify tab'\n % (nid, ndupl, DEFMINISI))\n raise RuntimeError(msg)\n\n def check_wavealign(self, nids='good', maxdti=1):\n \"\"\"Check that each neurons's primary peak on the max chan is no more than +/- maxdti\n timepoints away from the t=0 alignment timepoint\"\"\"\n print('Checking neuron mean waveform alignment')\n if nids == 'good':\n nids = self.good\n elif nids == 'all':\n nids = sorted(self.neurons)\n nt = self.twi[1] - self.twi[0] + 1 # expected number of points of each chan's wavedata\n for nid in nids:\n neuron = self.neurons[nid]\n wd = self.get_maxchan_wavedata(nid=nid)\n assert len(wd) == nt\n # find biggest positive and negative peaks, check which comes first, ensure\n # the primary peak is within maxdti of t=0 alignment timepoint:\n ppeakis, _ = scipy.signal.find_peaks(wd) # positive peak indices\n npeakis, _ = scipy.signal.find_peaks(-wd) # negative peak indices\n pmaxi = ppeakis[wd[ppeakis].argmax()] # max positive peak index\n nmaxi = npeakis[wd[npeakis].argmin()] # max negative peak index\n if nmaxi < pmaxi: # usual case: -ve then +ve peak\n peak1i = nmaxi\n else: # less common: +ve then -ve peak, make sure +ve peak is worthy of alignment\n pmax, nmax = wd[pmaxi], wd[nmaxi]\n if pmax > abs(nmax): # +ve peak is bigger than -ve peak, align to +ve peak\n peak1i = pmaxi\n else:\n peak1i = nmaxi # default to -ve peak\n alignti = 0 - self.twi[0] # +ve\n dti = peak1i - alignti\n #print(\"n%d: dti=%d\" % (nid, dti))\n if abs(dti) > maxdti:\n peak1uV = self.converter.AD2uV(wd[peak1i])\n peak1us = intround(self.tres*(peak1i-alignti))\n msg = ('Primary peak (%+d uV @ t=%d us) of n%d is %+d timepoints away from '\n 'the t=0 us alignment point. Shift it closer and try again'\n % (peak1uV, peak1us, nid, dti))\n raise RuntimeError(msg)\n\n def check_wavepadding(self, nids='good', npad=2):\n \"\"\"Check if any spikes are edge padded, presumably due to being shifted but not\n reloaded. For robustness, check for consistent signs of padding across all channels.\n An edge is considered padded if it does not change over npad datapoints\"\"\"\n print('Checking spike waveform padding')\n assert npad >= 2 # need at least 2 points to do a diff\n if nids == 'good':\n nids = self.good\n elif nids == 'all':\n nids = sorted(self.neurons)\n for nid in nids:\n neuron = self.neurons[nid]\n for sid in neuron.sids:\n wd = self.wavedata[sid] # multichannel waveform data\n # are left and right edges of wavedata identical for npad number of points?\n l, r = wd[:, :npad], wd[:, -npad:] # shape (nchans, npad)\n leftpadded = (np.diff(l, axis=1) == 0).all()\n rightpadded = (np.diff(r, axis=1) == 0).all()\n # handle case where spike is right after or right before a 0-padded\n # region of data due to gaps between experiments:\n if leftpadded:\n if (wd[:, 0] == 0).all():\n leftpadded = False\n if rightpadded:\n if (wd[:, -1] == 0).all():\n rightpadded = False\n if leftpadded or rightpadded:\n msg = ('n%d has s%d that looks like it has been padded.\\n'\n 'leftpadded, rightpadded = %r, %r\\n'\n 'Reload s%d or n%d or all spikes and try again'\n % (nid, sid, leftpadded, rightpadded, sid, nid))\n raise RuntimeError(msg)\n\n def check_contiguous_nids(self):\n \"\"\"Check that neuron IDs are contiguous (no gaps)\"\"\"\n print('Checking that neuron IDs are contiguous')\n nids = np.array(list(self.neurons))\n nids = nids[nids > 0] # only consider +ve nids\n nids.sort()\n if (np.diff(nids) != 1).any():\n raise RuntimeError('Neuron IDs are not contiguous, renumber all and try again')\n\n def exportptcsfiles(self, basepath, sortpath, user='', notes=''):\n \"\"\"Export spike data to binary .ptcs files under basepath, one file per recording\"\"\"\n # First check to make sure various things are OK before exporting:\n self.check_ISIs()\n self.check_wavealign()\n self.check_wavepadding()\n self.check_contiguous_nids()\n spikes = self.spikes\n exportdt = str(datetime.datetime.now()) # get an export datetime stamp\n exportdt = exportdt.split('.')[0] # ditch the us\n if self.stream.is_multi(): # self.stream is a MultiStream\n streams = self.stream.streams\n else: # self.stream is a single Stream\n streams = [self.stream]\n print('Exporting \"good\" clusters to:')\n # do a separate export for each recording:\n # absolute start and stop times of all streams, rounded to nearest raw timepoint:\n tranges = self.stream.tranges\n t0 = tranges[0, 0] # absolute start time of first stream\n for stream, trange in zip(streams, tranges):\n abst0 = trange[0] # absolute start time of this stream relative to t0\n # time delta between this stream and first stream, to nearest raw timepoint, us:\n dt = abst0 - t0\n dt = intround(dt) # to nearest int us\n self.exportptcsfile(stream, basepath, dt, exportdt, sortpath,\n user=user, notes=notes)\n\n def exportptcsfile(self, stream, basepath, dt, exportdt, sortpath, user='', notes=''):\n \"\"\"Export spike data of all \"good\" spikes to binary .ptcs file in basepath.\n Constrain to spikes in stream, and undo any time delta in spike times.\n dt is the integer time difference between start of stream and start of first stream in\n the track, rounded to the nearest us (spike times are stored as int64 us in .ptcs)\"\"\"\n\n # build up list of PTCSNeuronRecords that have spikes in this stream,\n # and tally their spikes\n nsamplebytes = 4 # float32\n nrecs = []\n nspikes = 0\n # only export neurons marked as \"good\", could be single or multi unit:\n for nid in sorted(self.good):\n neuron = self.neurons[nid]\n spikets = self.spikes['t'][neuron.sids] # should be a sorted copy\n assert spikets.flags['OWNDATA'] # safe to modify in place\n spikets.sort() # just in case it isn't perfectly sorted\n spikets -= dt # export spike times relative to t=0 of this recording\n # only include spikes that occurred during this recording\n lo, hi = spikets.searchsorted([stream.t0, stream.t1])\n spikets = spikets[lo:hi]\n if len(spikets) == 0:\n continue # don't save empty neurons\n nrec = PTCSNeuronRecord(neuron, spikets, nsamplebytes, descr='')\n nrecs.append(nrec)\n nspikes += len(spikets)\n nneurons = len(nrecs)\n\n # create the header and write everything to file:\n path = os.path.join(basepath, stream.srcfnameroot)\n try: os.mkdir(path)\n except OSError: pass # path already exists?\n fname = stream.srcfnameroot + '.ptcs'\n fullfname = os.path.join(path, fname)\n header = PTCSHeader(self, sortpath, stream, nneurons, nspikes, nsamplebytes,\n fullfname, exportdt, user=user, notes=notes)\n \n with open(fullfname, 'wb') as f:\n header.write(f)\n for nrec in nrecs:\n nrec.write(f)\n print(fullfname)\n\n def exportcsv(self, fname):\n \"\"\"Export all \"good\" spikes to a .csv file with time (s), nid, and maxchan as the\n columns\"\"\"\n sids = []\n #chans = []\n for nid in sorted(self.good):\n neuron = self.neurons[nid]\n sids.append(neuron.sids)\n # the alternative is to export each spike's unit's channel:\n #chans.append(np.tile(neuron.chan, neuron.nspikes))\n sids = np.hstack(sids)\n spikes = self.spikes[sids]\n tsecs = spikes['t'] / 1e6 # convert from us to s\n nids = spikes['nid']\n chans = spikes['chan']\n #chans = np.hstack(chans)\n data = np.column_stack([tsecs, nids, chans])\n print('Exporting (tsec, nid, chan) of all spikes marked as \"good\" to %s' % fname)\n np.savetxt(fname, data, fmt='%.6f, %d, %d')\n\n def exporttschid(self, basepath):\n \"\"\"Export int64 (timestamp, channel, neuron id) 3 tuples to binary file\"\"\"\n raise NotImplementedError('Needs to be redone to work with multiple streams')\n spikes = self.spikes[self.spikes['nid'] > 0] # don't export unsorted/multiunit spikes\n dt = str(datetime.datetime.now()) # get an export timestamp\n dt = dt.split('.')[0] # ditch the us\n dt = dt.replace(' ', '_')\n dt = dt.replace(':', '.')\n srffnameroot = srffnameroot.replace(' ', '_')\n tschidfname = dt + '_' + srffnameroot + '.tschid'\n tschid = np.empty((len(spikes), 3), dtype=np.int64)\n tschid[:, 0] = spikes['t']\n tschid[:, 1] = spikes['chan']\n tschid[:, 2] = spikes['nid']\n tschid.tofile(os.path.join(path, tschidfname)) # save it\n print(tschidfname)\n\n def exportdin(self, basepath):\n \"\"\"Export stimulus din(s) to binary .din file(s) in basepath\"\"\"\n if self.stream.is_multi(): # self.stream is a MultiStream\n streams = self.stream.streams\n else: # self.stream is a single Stream\n streams = [self.stream]\n dinfiledtype=[('TimeStamp', '<i8'), ('SVal', '<i8')] # pairs of int64s\n print('Exporting DIN(s) to:')\n for stream in streams:\n try: # neither of these attribs should exist for recordings with no stimuli:\n svrecs = stream.srff.digitalsvalrecords\n dsprecs = stream.srff.displayrecords\n except AttributeError:\n continue # no din to export for this stream\n if len(svrecs) == 0 or stream.srff.ndigitalsvalrecords == 0:\n raise ValueError(\"digitalsvalrecords are empty for stream %r. Attribute \"\n \"shouldn't exist\" % stream.fname)\n path = os.path.join(basepath, stream.srcfnameroot)\n try: os.mkdir(path)\n except OSError: pass # path already exists?\n # upcast SVal field from uint16 to int64, creates a copy,\n # but it's not too expensive:\n svrecs = svrecs.astype(dinfiledtype)\n # convert to normal n x 2 int64 array\n svrecs = svrecs.view(np.int64).reshape(-1, 2)\n # Some old recordings (<= ptc15) contain multiple experiments.\n # To deal with this, iterate over stream.srff.displayrecords, export one .din\n # per displayrecord. Append experiment ID to each .din filename, if necessary.\n svrects = svrecs[:, 0]\n dsprects = [ dsprec.TimeStamp for dsprec in dsprecs ]\n svalrecis = svrects.searchsorted(dsprects)\n assert svalrecis[0] == 0\n svalrecis = svalrecis[1:] # exclude the trivial 0 index\n # split sval records according to displayrecord timestamps:\n dins = np.split(svrecs, svalrecis)\n assert len(dins) == len(dsprecs)\n for eid, din in enumerate(dins):\n if eid == 0 and len(dins) == 1:\n eidstr = ''\n elif len(dins) < 10:\n eidstr = '.%d' % eid\n else: # include leading zero to maintain alphabetical fname order\n eidstr = '.%02d' % eid\n dinfname = stream.srcfnameroot + eidstr + '.din'\n fullfname = os.path.join(path, dinfname)\n din.tofile(fullfname) # save it\n print(fullfname)\n\n def exporttextheader(self, basepath):\n \"\"\"Export stimulus text header(s) to .textheader file(s) in basepath\"\"\"\n if self.stream.is_multi(): # self.stream is a MultiStream\n streams = self.stream.streams\n else: # self.stream is a single Stream\n streams = [self.stream]\n print('Exporting text header(s) to:')\n for stream in streams:\n try:\n dsprecs = stream.srff.displayrecords\n except AttributeError: # no textheader to export for this stream\n continue\n if len(dsprecs) == 0:\n raise ValueError(\"displayrecords are empty for stream %r. Attribute \"\n \"shouldn't exist\" % stream.fname)\n path = os.path.join(basepath, stream.srcfnameroot)\n try: os.mkdir(path)\n except OSError: pass # path already exists?\n # Some old recordings (<= ptc15) contain multiple experiments.\n # To deal with this, iterate over stream.srff.displayrecords, export one\n # .textheader per displayrecord. Append experiment ID to each .textheader\n # filename, if necessary.\n for eid, dsprec in enumerate(dsprecs):\n textheader = dsprec.Header.python_tbl\n if eid == 0 and len(dsprecs) == 1:\n eidstr = ''\n elif len(dsprecs) < 10:\n eidstr = '.%d' % eid\n else: # include leading zero to maintain alphabetical fname order\n eidstr = '.%02d' % eid\n textheaderfname = stream.srcfnameroot + eidstr + '.textheader'\n fullfname = os.path.join(path, textheaderfname)\n with open(fullfname, 'w') as f:\n f.write(textheader) # save it\n print(fullfname)\n\n def exportall(self, basepath, sortpath):\n \"\"\"Export spike data, stimulus din and textheader to basepath\"\"\"\n self.exportptcsfiles(basepath, sortpath)\n self.exportdin(basepath)\n self.exporttextheader(basepath)\n\n def exportspikewaves(self, sids, selchans, tis, fname, format):\n \"\"\"Export spike waveform data of selected sids, selchans and tis to binary\n .spikes.zip file or text .spikes.csv file\"\"\"\n nspikes = len(sids)\n chans, chanslist = self.get_common_chans(sids, selchans)\n nchans = len(chans)\n ti0, ti1 = tis\n nt = ti1 - ti0\n # fill in 3D data array:\n dtype = self.wavedata.dtype\n data = np.zeros((nspikes, nchans, nt), dtype=dtype)\n for sii, sid in enumerate(sids):\n spikechans = chanslist[sii]\n spikechanis = spikechans.searchsorted(chans)\n data[sii] = self.wavedata[sid][spikechanis, ti0:ti1]\n if format == 'text': # flatten timepoints of all chans into columns\n data.shape = nspikes, nchans*nt\n stream = self.stream\n assert stream.kind == 'highpass' # should be the only type ever saved to self\n if format == 'binary':\n nids = self.spikes['nid'][sids]\n spiketimes = self.spikes['t'][sids]\n chanpos = stream.probe.siteloc_arr()\n uVperAD = stream.converter.AD2uV(1) # convert 1 AD unit to uV\n with open(fname, 'wb') as f:\n np.savez_compressed(f, data=data, sids=sids, nids=nids,\n spiketimes=spiketimes, chans=chans, tis=tis,\n chanpos=chanpos, uVperAD=uVperAD)\n elif format == 'text':\n np.savetxt(fname, data, fmt='%d', delimiter=',') # data should be int\n else:\n raise ValueError('Unknown format: %r' % format)\n print('Exported %d spikes on chans=%r and tis=%r to %s'\n % (nspikes, list(chans), list(tis), fname))\n \n def get_param_matrix(self, kind=None, sids=None, tis=None, selchans=None, norm=False,\n dims=None, scale=True):\n \"\"\"Organize dims parameters from sids into a data matrix, each column\n corresponding to a dim. To do PCA/ICA clustering on all spikes, one maxchan at\n a time, caller needs to call this multiple times, one for each set of\n maxchan unique spikes,\"\"\"\n spikes = self.spikes\n dtypefields = list(spikes.dtype.fields)\n if sids is None:\n sids = spikes['id'] # default to all spikes\n comps = [ dim for dim in dims if dim.startswith('c') and dim[-1].isdigit() ]\n rmserror = np.any([ dim == 'RMSerror' for dim in dims ])\n ncomp = len(comps)\n hascomps = ncomp > 0\n if hascomps:\n X = self.get_component_matrix(kind, sids, tis=tis, chans=selchans,\n minncomp=ncomp, norm=norm)\n if rmserror:\n rms = self.get_rms_error(sids, tis=tis, chans=selchans)\n\n data = []\n for dim in dims:\n if dim in dtypefields:\n data.append( np.float32(spikes[dim][sids]) )\n elif dim.startswith('c') and dim[-1].isdigit():\n compid = int(lstrip(dim, 'c'))\n data.append( np.float32(X[:, compid]) )\n elif dim == 'RMSerror':\n data.append( np.float32(rms) )\n else:\n raise RuntimeError('Unknown dim %r' % dim)\n # np.column_stack returns a copy, not modifying the original array\n data = np.column_stack(data)\n if scale:\n # ensure 0 mean, and unit variance/stdev\n for dim, d in zip(dims, data.T): # d iterates over columns\n d -= d.mean()\n if dim in ['x0', 'y0'] and self.probe.ncols > 1:\n try: x0std # normalize spatial params by x0 std\n except NameError: x0std = spikes['x0'].std()\n if x0std != 0.0:\n d /= x0std\n #elif dim == 't': # the longer the recording in hours, the greater the\n # # scaling in time\n # trange = d.max() - d.min()\n # tscale = trange / (60*60*1e6)\n # d *= tscale / d.std()\n else: # normalize all other dims by their std\n dstd = d.std()\n if dstd != 0.0:\n d /= dstd\n return data\n\n def get_component_matrix(self, kind, sids, tis=None, chans=None, minncomp=None,\n norm=False):\n \"\"\"Find set of chans common to all sids, and do PCA/ICA on those waveforms. Or,\n if chans are specified, limit PCA/ICA to them. Return component matrix with at\n least minncomp dimensions\"\"\"\n spikes = self.spikes\n nt = self.wavedata.shape[2]\n if tis is None: # use full waveform\n tis = np.asarray([0, nt])\n #print('tis: %r' % (tis,))\n ti0, ti1 = tis\n assert ti0 < ti1 <= nt\n nt = ti1 - ti0\n chans, chanslist = self.get_common_chans(sids, chans)\n nchans = len(chans)\n nspikes = len(sids)\n if nspikes < 2:\n raise RuntimeError(\"Need at least 2 spikes for %s\" % kind)\n if nchans == 0:\n raise RuntimeError(\"Spikes have no common chans for %s\" % kind)\n\n # check if desired components have already been calculated (cache hit):\n Xhash = self.get_Xhash(kind, sids, tis, chans, self.npcsperchan, norm)\n self.Xhash = Xhash # save as key to most recent component matrix in self.X\n try: self.X\n except AttributeError: self.X = {} # init the dimension reduction cache attrib\n if Xhash in self.X:\n print('Cache hit, using cached %ss from tis=%r, chans=%r of %d spikes' %\n (kind[:-1], list(tis), list(chans), nspikes))\n return self.X[Xhash] # no need to recalculate\n\n print('Cache miss, (re)calculating %ss' % kind[:-1])\n\n # collect data between tis from chans from all spikes:\n print('Doing %s on tis=%r, chans=%r of %d spikes' %\n (kind, list(tis), list(chans), nspikes))\n # MDP complains of roundoff errors with float32 for large covariance matrices\n data = np.zeros((nspikes, nchans, nt), dtype=np.float64)\n for sii, sid in enumerate(sids):\n spikechans = chanslist[sii]\n spikechanis = spikechans.searchsorted(chans)\n spikedata = self.wavedata[sid][spikechanis, ti0:ti1]\n if norm:\n # normalize by Vpp of chan with max Vpp:\n maxptp = spikedata.ptp(axis=1).max()\n if maxptp != 0: # prevent div by 0\n spikedata = spikedata / maxptp\n data[sii] = spikedata\n print('Input shape for %s: %r' % (kind, data.shape))\n t0 = time.time()\n data.shape = nspikes, nchans*nt # flatten timepoints of all chans into columns\n print('Reshaped input for %s: %r' % (kind, data.shape))\n if kind == 'PCA': # principal components analysis\n if PCALIB == 'mdp':\n import mdp # delay as late as possible\n X = mdp.pca(data, output_dim=5, svd=False) # svd=False is default\n elif PCALIB == 'sklearn':\n # sklearn's PCA is about 8x slower than mdp.pca, I think because it\n # doesn't tap into scipy.linalg.eig compiled code. RandomizedPCA is faster\n # than PCA, but isn't deterministic, and is still 2-3x slower than mdp.pca\n from sklearn.decomposition import PCA\n pca = PCA(n_components=5)\n X = pca.fit_transform(data) # do both the fit and the transform\n else:\n raise ValueError('Invalid PCALIB %r' % PCALIB)\n if X.shape[1] < minncomp:\n raise RuntimeError(\"Can't satisfy minncomp=%d request\" % minncomp)\n elif kind == 'sPCA': # sparse principal components analysis\n from sklearn.decomposition import SparsePCA\n n_components = 5\n alpha = 1 # sparseness parameter\n n_jobs = mp.cpu_count()\n spca = SparsePCA(n_components=n_components, alpha=alpha, n_jobs=n_jobs)\n X = spca.fit_transform(data) # do both the fit and the transform\n elif kind == 'mbsPCA': # mini batch sparse principal components analysis\n from sklearn.decomposition import MiniBatchSparsePCA\n n_components = 5\n alpha = 1 # sparseness parameter\n n_jobs = mp.cpu_count()\n mbspca = MiniBatchSparsePCA(n_components=n_components, alpha=alpha, n_jobs=n_jobs)\n X = mbspca.fit_transform(data) # do both the fit and the transform\n elif kind == 'NMF': # non-negative matrix factorization\n from sklearn.decomposition import NMF\n n_components = 5\n init = None # 'random', 'nndsvd', 'nndsvda', 'nndsvdar', 'custom'\n nmf = NMF(n_components=n_components, init=init)\n X = nmf.fit_transform(data) # do both the fit and the transform\n elif kind == 'tSNE': # t-distributed stochastic neighbor embedding\n # limit number of PCs to feed into ICA, keep up to npcsperchan components per\n # chan on average:\n ncomp = min((self.npcsperchan*nchans, data.shape[1]))\n print('ncomp: %d' % ncomp)\n import mdp # delay as late as possible\n # do PCA first, to reduce dimensionality and speed up ICA:\n data = mdp.pca(data, output_dim=ncomp)\n from sklearn.manifold import TSNE\n n_components = 3 # not suited for any more than 3, according to the paper\n #init = 'random', 'pca'\n tsne = TSNE(n_components=n_components)\n X = tsne.fit_transform(data) # do both the fit and the transform\n elif kind == 'ICA': # independent components analysis\n # ensure nspikes >= ndims**2 for good ICA convergence\n maxncomp = intround(np.sqrt(nspikes))\n if maxncomp < minncomp:\n raise RuntimeError(\"Can't satisfy minncomp=%d request\" % minncomp)\n if data.shape[0] <= data.shape[1]:\n raise RuntimeError('Need more observations than dimensions for ICA')\n # limit number of PCs to feed into ICA, keep up to npcsperchan components per\n # chan on average:\n ncomp = min((self.npcsperchan*nchans, maxncomp, data.shape[1]))\n if ICALIB == 'mdp':\n import mdp # delay as late as possible\n # do PCA first, to reduce dimensionality and speed up ICA:\n print('ncomp: %d' % ncomp)\n data = mdp.pca(data, output_dim=ncomp)\n # nonlinearity g='pow3', ie x**3. tanh seems to separate better,\n # but is a bit slower. gaus seems to be slower still, and no better\n # than tanh, but these are just vague impressions.\n # defaults to whitened=False, ie assumes data isn't whitened\n node = mdp.nodes.FastICANode(g='pow3')\n X = node(data)\n pm = node.get_projmatrix()\n X = X[:, np.any(pm, axis=0)] # keep only the non zero columns\n elif ICALIB == 'sklearn':\n from sklearn.decomposition import FastICA\n # when whiten=True (default), FastICA preprocesses the data using PCA, and\n # n_components is the number of PCs that are kept before doing ICA.\n alg = 'parallel' # parallel or deflation, default is parallel\n fun = 'logcosh' # logcosh, exp, or cube, default is logcosh\n maxiter = 100 # default is 200\n tol = 0.5 # default is 0.0001, seems need >~ 0.1 to exit faster\n ## TODO: make FastICA algorithm (parallel, deflation), nonlinearity (logcosh,\n ## exp, cube) and IC sort method (abs(kurtosis) vs. negentropy) GUI options\n print('ncomp=%d, alg=%r, fun=%r, maxiter=%d, tol=%g'\n % (ncomp, alg, fun, maxiter, tol))\n fastica = FastICA(n_components=ncomp, algorithm=alg,\n whiten=True, fun=fun, fun_args=None,\n max_iter=maxiter, tol=tol, w_init=None,\n random_state=None)\n X = fastica.fit_transform(data) # do both the fit and the transform\n #pm = fastica.components_\n print('fastica niters: %d' % (fastica.n_iter_))\n else:\n raise ValueError('Invalid ICALIB %r' % ICALIB)\n if X.shape[1] < 3:\n raise RuntimeError('Need at least 3 columns')\n\n # Sort ICs by decreasing kurtosis or negentropy. For kurtosis, see Scholz2004 (or\n # rather, opposite to their approach, which picked ICs with most negative\n # kurtosis). For methods of estimating negentropy, see Hyvarinen1997.\n\n '''\n # sort by abs(kurtosis) of each IC (column)\n k = scipy.stats.kurtosis(X, axis=0)\n ki = abs(k).argsort()[::-1] # decreasing order of abs(kurtosis)\n print('Sort by abs(kurtosis):')\n print(k[ki])\n X = X[:, ki] # sort the ICs\n '''\n # sort by negentropy of each IC (column), this seems to work better than kurtosis\n # at separating clusters of similar size:\n ne = core.negentropy(X, axis=0)\n assert (ne > 0).all()\n nei = ne.argsort()[::-1] # decreasing order of negentropy\n print('Sort by negentropy:')\n print(ne[nei])\n X = X[:, nei] # sort the ICs\n '''\n import pylab as pl\n pl.figure()\n pl.imshow(pm)\n pl.colorbar()\n pl.title('original projmatrix')\n pl.figure()\n pl.imshow(pm[:, ki])\n pl.colorbar()\n pl.title('decreasing abs(kurtosis) projmatrix')\n pl.figure()\n pl.imshow(pm[:, nei])\n pl.colorbar()\n pl.title('decreasing negentropy projmatrix')\n '''\n else:\n raise ValueError('Unknown kind %r' % kind)\n print('Output shape for %s: %r' % (kind, X.shape))\n self.X[Xhash] = X # cache for fast future retrieval\n print('%s took %.3f sec' % (kind, time.time()-t0))\n unids = list(np.unique(spikes['nid'][sids])) # set of all nids that sids span\n for nid in unids:\n # don't update pos of junk cluster, if any, since it might not have any chans\n # common to all its spikes, and therefore can't have PCA/ICA done on it\n if nid != 0:\n self.clusters[nid].update_comppos(X, sids)\n return X\n\n def get_rms_error(self, sids, tis=None, chans=None):\n \"\"\"Calculate RMS error of spike waveforms (all from the same cluster) relative to\n their cluster's mean waveform. Consider only selected tis and chans\"\"\"\n spikes = self.spikes\n nids = np.unique(spikes['nid'][sids])\n nid = nids[0]\n if len(nids) > 1 or nid == 0:\n raise RuntimeError(\"Spikes must all belong to the same (non-junk) cluster for \"\n \"RMS error calculation\")\n nt = self.wavedata.shape[2]\n if tis is None: # use full waveform\n tis = np.asarray([0, nt])\n #print('tis: %r' % (tis,))\n ti0, ti1 = tis\n assert ti0 < ti1 <= nt\n nt = ti1 - ti0\n chans, chanslist = self.get_common_chans(sids, chans)\n nchans = len(chans)\n nspikes = len(sids)\n if nchans == 0:\n raise RuntimeError(\"Spikes have no common chans for RMS error\")\n\n # collect data between tis from chans from all spikes:\n print('Getting RMS error on tis=%r, chans=%r of %d spikes' %\n (list(tis), list(chans), nspikes))\n data = np.zeros((nspikes, nchans, nt), dtype=np.float64)\n for sii, sid in enumerate(sids):\n spikechans = chanslist[sii]\n spikechanis = spikechans.searchsorted(chans)\n data[sii] = self.wavedata[sid][spikechanis, ti0:ti1]\n\n # get cluster mean waveform between tis on chans:\n wave = self.neurons[nid].get_wave()\n chanis = wave.chans.searchsorted(chans)\n meandata = np.float64(wave.data[chanis, ti0:ti1])\n\n # calculate RMS error between each spike and the cluster mean waveform:\n se = (data - meandata) ** 2 # squared error\n # take mean across timepoints and chans, but not across spikes:\n mse = se.mean(axis=2).mean(axis=1) # mean squared error\n return np.sqrt(mse)\n\n def get_common_chans(self, sids, chans=None):\n \"\"\"Find channels common to all sids, and optionally to chans as well. Also,\n return chanslist, ie list of arrays of chans of sids\"\"\"\n spikes = self.spikes\n chanss = spikes['chans'][sids]\n nchanss = spikes['nchans'][sids]\n #t0 = time.time()\n chanslist = [ cs[:ncs] for cs, ncs in zip(chanss, nchanss) ] # list of arrays\n #print('Building chanslist took %.3f sec' % (time.time()-t0))\n commonchans = util.intersect1d_uint8(chanslist) # find intersection\n if chans is not None and len(chans) > 0:\n # values in chans but not in commonchans:\n diffchans = np.setdiff1d(chans, commonchans)\n commonchans = np.intersect1d(chans, commonchans) # values in both\n if len(diffchans) > 0:\n print('WARNING: ignored chans %r not common to all spikes' % list(diffchans))\n return commonchans, chanslist\n\n def get_Xhash(self, kind, sids, tis, chans, npcsperchan, norm):\n \"\"\"Return MD5 hex digest of args, for uniquely identifying the matrix resulting\n from dimension reduction of spike data\"\"\"\n h = hashlib.md5()\n h.update(kind.encode())\n h.update(sids)\n h.update(tis)\n h.update(chans)\n if kind == 'ICA': # consider npcsperchan only if doing ICA\n h.update(str(npcsperchan).encode())\n h.update(str(norm).encode())\n return h.hexdigest()\n\n def create_neuron(self, id=None, inserti=None):\n \"\"\"Create and return a new Neuron with a unique ID\"\"\"\n if id == None:\n id = self.nextnid\n if id in self.neurons:\n raise RuntimeError('Neuron %d already exists' % id)\n id = int(id) # get rid of numpy ints\n neuron = Neuron(self, id)\n # add neuron to self\n self.neurons[neuron.id] = neuron\n if inserti == None:\n self.norder.append(neuron.id)\n else:\n self.norder.insert(inserti, neuron.id)\n return neuron\n\n def remove_neuron(self, id):\n try:\n del self.neurons[id] # may already be removed due to recursive call\n del self.clusters[id]\n self.norder.remove(id)\n except (KeyError, ValueError):\n pass\n\n def shift(self, sids, nt):\n \"\"\"Shift sid waveforms by nt timepoints: -ve shifts waveforms left, +ve shifts right.\n For speed, pad waveforms with edge values at the appropriate end\"\"\"\n spikes = self.spikes\n wd = self.wavedata\n for sid in sids: # maybe there's a more efficient way than iterating over sids\n core.shiftpad(wd[sid], nt) # modifies wd in-place\n # update spike parameters:\n dt = intround(nt * self.tres) # amount of time to shift by, signed, in us\n # so we can later reload the wavedata accurately, shifting the waveform right and\n # padding it on its left requires decrementing the associated timepoints\n # (and vice versa)\n spikes['t'][sids] -= dt\n spikes['t0'][sids] -= dt\n spikes['t1'][sids] -= dt\n # might result in some out of bounds tis because the original peaks\n # have shifted off the ends. Opposite sign wrt timepoints above, referencing within\n # wavedata:\n spikes['tis'][sids] = spikes['tis'][sids] + nt\n # this in-place operation raises a TypeError in numpy 1.11.2, something related to\n # subtracting an int from an unsigned int:\n #spikes['tis'][sid] += nt\n # caller should treat all sids as dirty\n '''\n # replaced by util.alignbest_cy():\n def alignbest(self, sids, tis, chans):\n \"\"\"Align all sids between tis on chans by best fit according to mean squared error.\n chans are assumed to be a subset of channels of sids. Return sids\n that were actually moved and therefore need to be marked as dirty\"\"\"\n spikes = self.spikes\n nspikes = len(sids)\n nchans = len(chans)\n wd = self.wavedata\n nt = wd.shape[2] # num timepoints in each waveform\n ti0, ti1 = tis\n subnt = ti1 - ti0 # num timepoints to slice from each waveform\n # TODO: make maxshift a f'n of interpolation factor\n maxshift = 2 # shift +/- this many timepoints\n subntdiv2 = subnt // 2\n #print('subntdiv2 on either side of t=0: %d' % subntdiv2)\n if subntdiv2 < maxshift:\n raise ValueError(\"Selected waveform duration too short\")\n #maxshiftus = maxshift * self.stream.tres\n # NOTE: in this case, it may be faster to keep shifts and sti0s and sti1s as lists\n # of ints instead of np int arrays, maybe because their values are faster to iterate\n # over or index with in python loops and lists:\n shifts = range(-maxshift, maxshift+1) # from -maxshift to maxshift, inclusive\n nshifts = len(shifts)\n sti0s = [ ti0+shifti for shifti in range(nshifts) ] # shifted ti0 values\n sti1s = [ ti1+shifti for shifti in range(nshifts) ] # shifted ti1 values\n sti0ssti1s = zip(sti0s, sti1s)\n print(\"Padding waveforms with up to +/- %d points of fake data\" % maxshift)\n\n # not worth subsampling here while calculating meandata, since all this\n # stuff in this loop is needed in the shift loop below\n subsd = np.zeros((nspikes, nchans, subnt), dtype=wd.dtype) # subset of spike data\n spikechanis = np.zeros((nspikes, nchans), dtype=np.int64)\n t0 = time.time()\n for sidi, sid in enumerate(sids):\n spike = spikes[sid]\n nspikechans = spike['nchans']\n spikechans = spike['chans'][:nspikechans]\n spikechanis[sidi] = spikechans.searchsorted(chans)\n subsd[sidi] = wd[sid, spikechanis[sidi], ti0:ti1]\n print('Mean prep loop for best shift took %.3f sec' % (time.time()-t0))\n t0 = time.time()\n meandata = subsd.mean(axis=0) # float64\n print('Mean for best shift took %.3f sec' % (time.time()-t0))\n\n # choose best shifted waveform for each spike\n # widesd holds current spike data plus padding on either side\n # to allow for full width slicing for all time shifts:\n maxnchans = spikes['nchans'].max() # of all spikes in sort\n widesd = np.zeros((maxnchans, maxshift+nt+maxshift), dtype=wd.dtype) \n shiftedsubsd = subsd.copy() # init\n tempsubshifts = np.zeros((nshifts, nchans, subnt), dtype=wd.dtype)\n dirtysids = []\n t0 = time.time()\n for sidi, sid in enumerate(sids):\n # for speed, instead of adding real data, pad start and end with fake values\n chanis = spikechanis[sidi]\n sd = wd[sid] # sid's spike data\n widesd[:, maxshift:-maxshift] = sd # 2D\n widesd[:, :maxshift] = sd[:, 0, None] # pad start with first point per chan\n widesd[:, -maxshift:] = sd[:, -1, None] # pad end with last point per chan\n wideshortsd = widesd[chanis] # sid's padded spike data on chanis, 2D\n\n # keep this inner loop as fast as possible:\n for shifti, (sti0, sti1) in enumerate(sti0ssti1s):\n tempsubshifts[shifti] = wideshortsd[:, sti0:sti1] # len: subnt\n \n errors = tempsubshifts - meandata # (nshifts, nchans, subnt) - (nchans, subnt)\n # get sum squared errors by taking sum across highest two dims - for purpose\n # of error comparison, don't need to take mean or square root. Also, order\n # of summation along axes doesn't matter, as long as it's done on the highest two:\n sserrors = (errors**2).sum(axis=2).sum(axis=1) # nshifts long\n bestshifti = sserrors.argmin()\n bestshift = shifts[bestshifti]\n if bestshift != 0: # no need to update sort.wavedata[sid] if there's no shift\n # update time values:\n dt = bestshift * self.tres # time to shift by, signed, in us\n spikes['t'][sid] += dt # should remain halfway between t0 and t1\n spikes['t0'][sid] += dt\n spikes['t1'][sid] += dt\n # might result in some out of bounds tis because the original peaks\n # have shifted off the ends. Opposite sign, referencing within wavedata:\n spikes['tis'][sid] -= bestshift\n # update sort.wavedata\n wd[sid] = widesd[:, bestshifti:bestshifti+nt]\n shiftedsubsd[sidi] = tempsubshifts[bestshifti]\n dirtysids.append(sid) # mark sid as dirty\n print('Shifting loop took %.3f sec' % (time.time()-t0))\n AD2uV = self.converter.AD2uV\n stdevbefore = AD2uV(subsd.std(axis=0).mean())\n stdevafter = AD2uV(shiftedsubsd.std(axis=0).mean())\n print('stdev went from %.3f to %.3f uV' % (stdevbefore, stdevafter))\n return dirtysids\n '''\n def alignminmax(self, sids, to):\n \"\"\"Align sids by their min or max. Return those that were actually moved\n and therefore need to be marked as dirty\"\"\"\n if not self.stream.is_open():\n raise RuntimeError(\"No open stream to reload spikes from\")\n spikes = self.spikes\n V0s = spikes['V0'][sids]\n V1s = spikes['V1'][sids]\n Vss = np.column_stack((V0s, V1s))\n alignis = spikes['aligni'][sids]\n b = np.column_stack((alignis==0, alignis==1)) # 2D boolean array\n if to == 'min':\n i = Vss[b] > 0 # indices into sids of spikes aligned to the max peak\n elif to == 'max':\n i = Vss[b] < 0 # indices into sids of spikes aligned to the min peak\n else:\n raise ValueError('Unknown to %r' % to)\n sids = sids[i] # sids that need realigning\n nspikes = len(sids)\n print(\"Realigning %d spikes\" % nspikes)\n if nspikes == 0: # nothing to do\n return [] # no sids to mark as dirty\n\n multichantis = spikes['tis'][sids] # nspikes x nchans x 2 arr\n chanis = spikes['chani'][sids] # nspikes arr of max chanis\n # peak tis on max chan of each spike, convert from uint8 to int32 for safe math\n tis = np.int32(multichantis[np.arange(nspikes), chanis]) # nspikes x 2 arr\n # NOTE: tis aren't always in temporal order!\n dpeaktis = tis[:, 1] - tis[:, 0] # could be +ve or -ve\n dpeaks = spikes['dt'][sids] # stored as +ve\n\n # for each spike, decide whether to add or subtract dpeak to/from its temporal values\n ordered = dpeaktis > 0 # in temporal order\n reversed = dpeaktis < 0 # in reversed temporal order\n alignis = spikes['aligni'][sids]\n alignis0 = alignis == 0\n alignis1 = alignis == 1\n dpeaki = np.zeros(nspikes, dtype=int)\n # add dpeak to temporal values to align to later peak\n dpeaki[ordered & alignis0 | reversed & alignis1] = 1\n # subtact dpeak from temporal values to align to earlier peak\n dpeaki[ordered & alignis1 | reversed & alignis0] = -1\n\n # upcast aligni from 1 byte to an int before doing arithmetic on it:\n #dalignis = -np.int32(alignis)*2 + 1\n dts = dpeaki * dpeaks\n dtis = -dpeaki * abs(dpeaktis)\n # shift values\n spikes['t'][sids] += dts\n spikes['t0'][sids] += dts\n spikes['t1'][sids] += dts\n spikes['tis'][sids] = spikes['tis'][sids] + dtis[:, None, None] # update wrt new t0i\n spikes['aligni'][sids[alignis0]] = 1\n spikes['aligni'][sids[alignis1]] = 0\n\n # update wavedata for each shifted spike\n self.reload_spikes(sids)\n return sids # mark all sids as dirty\n\n def choose_new_meanchans(self, sids):\n \"\"\"Get mean waveform of all sids, then find the mean's chan with max Vpp, then\n choose det.maxnchansperspike channels around that maxchan.\n Return meanchans, furthestchan, and furthestchani\"\"\"\n print('Choosing new channel set for all selected spikes')\n det = self.detector\n meanwave = self.get_mean_wave(sids)\n # mean chan with max Vpp:\n maxchan = meanwave.chans[meanwave.data.ptp(axis=1).argmax()]\n maxchani = det.chans.searchsorted(maxchan)\n distances = det.dm.data[maxchani]\n # keep the maxnchansperspike closest chans to maxchan, including maxchan:\n chanis = distances.argsort()[:det.maxnchansperspike]\n meanchans = det.chans[chanis]\n meanchans.sort() # keep them sorted\n print('meanchans: %r' % list(meanchans))\n furthestchan = det.chans[chanis[-1]]\n print('furthestchan: %d' % furthestchan)\n furthestchani = meanchans.searchsorted(furthestchan)\n # sanity checks:\n assert len(meanchans) == det.maxnchansperspike\n assert maxchan in meanchans\n return meanchans, furthestchan, furthestchani\n\n def reload_spikes(self, sids, usemeanchans=False):\n \"\"\"Update wavedata of designated spikes from stream. Optionally fix incorrect\n time values from .sort 0.3 files. Optionally choose new set of channels for all\n sids based on the chans closest to the mean of the sids. It's the caller's\n responsibility to mark sids as dirty and trigger resaving of .wave file\"\"\"\n\n ## TODO: add findmaxchan=False and recenteronmaxchan=False kwargs\n\n nsids = len(sids)\n print('(Re)loading %d spikes' % nsids)\n stream = self.stream\n if not stream.is_open():\n raise RuntimeError(\"No open stream to reload spikes from\")\n spikes = self.spikes\n det = self.detector\n ver_lte_03 = float(self.__version__) <= 0.3\n if ver_lte_03:\n print('Fixing potentially incorrect time values during spike reloading')\n nfixed = 0\n treload = time.time()\n if usemeanchans:\n if ver_lte_03:\n raise RuntimeError(\"Best not to choose new chans from mean until after \"\n \"converting to .sort >= 0.4\")\n meanchans, furthestchan, furthestchani = self.choose_new_meanchans(sids)\n nmeanchans = len(meanchans)\n\n # split up sids into groups efficient for loading from stream:\n ts = spikes[sids]['t'] # noncontig, not a copy\n # ensure they're in temporal order:\n if not (np.diff(ts) >= 0).all():\n print(\"Selected sids aren't in temporal order, sorting by time...\")\n tsis = ts.argsort()\n sids = sids[tsis]\n print(\"Done sorting sids by time\")\n # break up spikes by ISIs >= MAXGROUPISI:\n splitis = np.where(np.diff(ts) >= MAXGROUPISI)[0] + 1\n groups = np.split(sids, splitis)\n # limit each group of sids to no more than MAXGROUPDT:\n groupi = 0\n while groupi < len(groups):\n group = groups[groupi] # group of sids all with ISIs < MAXGROUPISI\n ## TODO: not a copy: is this the optimal way to get the times in this case?\n relts = spikes[group]['t'] - spikes[group[0]]['t']\n splitis = np.where(np.diff(relts // MAXGROUPDT) > 0)[0] + 1\n nsubgroups = len(splitis) + 1\n if nsubgroups > 1:\n # del original group, replace with subgroups\n del groups[groupi]\n subgroups = np.split(group, splitis)\n groups[groupi:groupi] = subgroups\n groupi += len(subgroups)\n else:\n groupi += 1\n print('ngroups: %d' % len(groups))\n\n # process each group:\n sidi = 0 # init sid index across all groups, used as status counter\n for groupi, group in enumerate(groups):\n printflush('<%d>' % groupi, end='')\n assert len(group) > 0 # otherwise something went wrong above\n t0 = spikes[group[0]]['t0']\n t1 = spikes[group[-1]]['t1']\n if ver_lte_03:\n # load a little extra, in case we need to reload misaligned first and/or\n # last spike in this group\n t0 -= 5000 # -5 ms\n t1 += 5000 # +5 ms\n \"\"\"\n Find union of chans of sids in this group, ask Stream for only those such that no\n unnecessary resampling takes place on unneeded chans. Note that this doesn't make\n a difference when CAR is enabled in the stream, because the full set of enabled\n chans have to be maintained in Stream.__call__ until the very end. Don't bother\n cutting out the correct nchans for each sid. At worst, chan 0 (the \"empty\" chans\n array value) will be unnecessarily added to unionchans, and we'll retrieve one\n extra chan when creating tempwave, which will then later be discarded:\n \"\"\"\n unionchans = np.unique(spikes['chans'][group])\n if usemeanchans:\n # now that we have the original unionchans of this group,\n # update this group's spikes array entries with meanchans:\n spikes['nchans'][group] = nmeanchans\n # we're using the max num chans, so assign the full array:\n spikes['chans'][group] = meanchans\n # now update unionchans as well:\n unionchans = np.unique(np.hstack((unionchans, meanchans)))\n if 0 not in stream.chans: # if chan 0 is disabled in stream\n # remove 0 from unionchans, otherwise an error would be raised when\n # calling stream()\n unionchans = unionchans[unionchans != 0]\n # load and resample only what's needed for this group:\n tempwave = stream(t0, t1, unionchans)\n # slice out each spike's reloaded data from tempwave:\n for sid in group:\n # print status:\n if sidi % 10000 == 0:\n printflush(sidi, end='')\n elif sidi % 1000 == 0:\n printflush('.', end='')\n if usemeanchans: # already checked above that ver_lte_03 == False\n # this spike's chans have been set to meanchans, now\n # check that each spike's maxchan is in meanchans:\n chan = spikes[sid]['chan']\n if chan not in meanchans:\n # replace furthest chan with spike's maxchan:\n print(\"spike %d: replacing furthestchan %d with spike's maxchan %d\"\n % (sid, furthestchan, chan))\n nchans = spikes[sid]['nchans']\n chans = spikes[sid]['chans'][:nchans]\n # replace furthest chan with max chan, modifies spikes array in-place:\n chans[furthestchani] = chan\n # make sure chans remain sorted:\n chans.sort()\n # this isn't necessary, because all the above was in-place:\n #spikes['chans'][sid][:nchans] = chans\n spike = spikes[sid]\n nchans = spike['nchans']\n chans = spike['chans'][:nchans]\n rd = tempwave[spike['t0']:spike['t1']][chans].data # reloaded data\n if ver_lte_03: # fix potentially incorrect spike tis\n result = self.reload_spike_ver_lte_03(sid, nchans, tempwave, rd)\n if result == None:\n sidi += 1 # inc status counter\n continue # rollwin2D won't work, skip to next sid\n else:\n rd, fixed = result\n if fixed:\n nfixed += 1\n nt = rd.shape[1]\n self.wavedata[sid, :nchans, :nt] = rd # update wavedata\n sidi += 1 # inc status counter\n print()\n\n if ver_lte_03:\n print('Fixed time values of %d spikes' % nfixed)\n print('(Re)loaded %d spikes, took %.3f sec' % (len(sids), time.time()-treload))\n\n def reload_spike_ver_lte_03(self, sid, nchans, tempwave, rd):\n \"\"\"In sort.__version__ <= 0.3, t, t0, t1, and tis were not updated\n during alignbest() calls. To fix this, load new data with old potentially\n incorrect t0 and t1 values, and compare this new data to existing old data\n in wavedata array. Find where the non-repeating parts of the old data fits\n into the new, and calculate the correction needed to fix the time values.\n Finally, reload new data according to these corrected time values.\"\"\"\n #print('Reloading sid from ver_lte_03: %d' % sid)\n od = self.wavedata[sid, :nchans] # old data\n # indices that strip const values from left and right ends:\n lefti, righti = lrrep2Darrstripis(od)\n od = od[:, lefti:righti] # stripped old data\n # reloaded data rd uses old incorrect t0 and t1, but they should be\n # wide enough to encompass the non-repeating parts of the old data\n width = od.shape[1] # rolling window width\n if not width <= rd.shape[1]:\n print('') # newline\n print(\"WARNING: od.shape[1]=%d > rd.shape[1]=%d for sid %d\" %\n (od.shape[1], rd.shape[1], sid))\n #import pdb; pdb.set_trace()\n return\n odinndis = np.where((rollwin2D(rd, width) == od).all(axis=1).all(axis=1))[0]\n if len(odinndis) == 0: # no hits of old data in new\n dnt = 0 # reload data based on current timepoints\n elif len(odinndis) == 1: # exactly 1 hit of old data in new\n odinndi = odinndis[0] # pull it out\n dnt = odinndi - lefti # num timepoints to correct by, signed\n else:\n raise RuntimeError(\"Multiple hits of old data in new, don't know \"\n \"how to reload spike %d\" % sid)\n newrd, fixed = rd, False\n if dnt != 0:\n dt = intround(dnt * self.tres) # time to correct by, signed, in us\n spikes['t'][sid] += dt # should remain halfway between t0 and t1\n spikes['t0'][sid] += dt\n spikes['t1'][sid] += dt\n # might result in some out of bounds tis because the original peaks\n # have shifted off the ends. Use opposite sign because we're\n # referencing within wavedata:\n # in versions <= 0.3, 'tis' were named 'phasetis':\n spikes['phasetis'][sid] = spikes['phasetis'][sid] - dnt\n spike = spikes[sid]\n # reslice tempwave again now that t0 and t1 have changed\n newrd = tempwave[spike['t0']:spike['t1']][chans].data\n fixed = True\n #printflush('F', end='')\n return newrd, fixed\n\n def reload_spikes_and_templates(self, sids, usemeanchans=False):\n self.reload_spikes(sids, usemeanchans=usemeanchans)\n # update neuron templates:\n unids = np.unique(self.spikes['nid'][sids])\n unids = unids[unids != 0] # exclude junk cluster, which doesn't have a neuron\n neurons = [ self.neurons[nid] for nid in unids ]\n for neuron in neurons:\n neuron.update_wave() # update affected mean waveforms\n\n def init_spike_alignment(self):\n \"\"\"Set initial spike alignment points according to alignment points of each\n spike's neuron\"\"\"\n print('Setting initial spike alignment points')\n ntis, nalignis = {}, {} # tis and aligni derived from each neuron's mean waveform\n for neuron in self.neurons.values():\n nwave = neuron.get_wave() # update and return mean waveform\n mintis = nwave.data.argmin(axis=1)\n maxtis = nwave.data.argmax(axis=1)\n ntis[neuron.id] = np.column_stack([mintis, maxtis])\n # choose aligni with least variance:\n nalignis[neuron.id] = np.argmin([mintis.std(), maxtis.std()])\n AD2uV = self.converter.AD2uV\n for s, wd in zip(self.spikes, self.wavedata):\n sid = s['id']\n # print out progress on a regular basis:\n if sid % 100000 == 0:\n printflush(sid, end='')\n elif sid % 10000 == 0:\n printflush('.', end='')\n nid = s['nid']\n #chan = s['chan']\n nchans = s['nchans']\n chans = s['chans'][:nchans]\n neuronchans = self.neurons[nid].wave.chans\n assert (chans == neuronchans).all()\n s['tis'][:nchans] = ntis[nid] # set according to its neuron, wrt t0i=0\n s['aligni'] = nalignis[nid] # set according to its neuron\n maxchani = s['chani']\n t0i, t1i = int(s['tis'][maxchani, 0]), int(s['tis'][maxchani, 1])\n s['dt'] = abs(t1i - t0i) / self.sampfreq * 1e6 # us\n # note that V0 and V1 might not be of opposite sign, because tis are derived\n # from mean neuron waveform, not from each individual spike:\n s['V0'], s['V1'] = AD2uV(wd[maxchani, t0i]), wd[maxchani, t1i] # uV\n s['Vpp'] = abs(s['V1'] - s['V0']) # uV\n print()\n\n def spatially_localize_spikes(self, sortwin, method='fit'):\n \"\"\"Assuming that wavedata have been extracted and neuron mean waveforms calculated,\n find tis and perform spatial localization of every spike in self\"\"\"\n det = self.detector\n weights2f = self.extractor.weights2spatial\n weights2spatialmean = self.extractor.weights2spatialmean\n f = self.extractor.f\n nreject = 0 # number spikes rejected during spatial localization\n print('Running spatial localization on all %d spikes' % self.nspikes)\n tstart = time.clock()\n\n ## TODO: chan this be multithreaded/processed?\n\n for s, wd in zip(self.spikes, self.wavedata):\n # Get Vpp at each inclchan's tis, use as spatial weights:\n # see core.rowtake() or util.rowtake_cy() for indexing explanation:\n sid = s['id']\n # print out progress on a regular basis:\n if sid % 10000 == 0:\n printflush(sid, end='')\n elif sid % 1000 == 0:\n printflush('.', end='')\n chan = s['chan']\n nchans = s['nchans']\n chans = s['chans'][:nchans]\n maxchani = s['chani']\n chanis = det.chans.searchsorted(chans)\n w = np.float32(wd[np.arange(s['nchans'])[:, None], s['tis'][:nchans]]) # nchans x 2\n w = abs(w).sum(axis=1) # Vpp for each chan, measured at t0i and t1i\n x = det.siteloc[chanis, 0] # 1D array (row)\n y = det.siteloc[chanis, 1]\n if method == 'fit':\n # localize by fitting extractor.f function to wavedata\n params = weights2f(f, w, x, y, maxchani)\n elif method == 'mean':\n # set localization to Vpp-weighted spatial mean and 0 sigma:\n x0, y0 = weights2spatialmean(w, x, y)\n # a very ad-hoc guess for spatial sigma:\n sx = 2 * dist((x0, y0), self.probe.SiteLoc[chan])\n params = x0, y0, sx, sx\n else:\n print('Unknown method %r' % method)\n if params == None: # presumably a non-localizable many-channel noise event\n #printflush('X', end='') # to indicate a rejected spike\n if DEBUG:\n spiket = intround(s['t']) # nearest us\n det.log(\"Reject spike %d at t=%d based on fit params\" % (sid, spiket))\n neuron = self.neurons[s['nid']]\n # remove from its neuron, add to unsorted list of spikes:\n sortwin.MoveSpikes2List(neuron, [sid], update=False)\n # manually set localization params to Vpp-weighted spatial mean and 0 sigma:\n x0, y0 = weights2spatialmean(w, x, y)\n # set sigma to 0 um, and then later round lockr up to 1 um so that only one\n # raster tick shows up for each rejected spike, reducing clutter\n params = x0, y0, 0, 0\n nreject += 1\n # Save spatial fit params, and \"lockout\" only the channels within lockrx*sx\n # of the fit spatial location of the spike, up to a max of inclr. \"Lockout\"\n # in this case only refers to which channels are highlighted with a raster tick\n # for each spike:\n s['x0'], s['y0'], s['sx'], s['sy'] = params\n x0, y0 = s['x0'], s['y0']\n # lockout radius for this spike:\n lockr = min(det.lockrx*s['sx'], det.inclr) # in um\n lockr = max(lockr, 1) # at least 1 um, so at least the maxchan gets a tick\n # test y coords of chans in y array, ylockchaniis can be used to index\n # into x, y and chans:\n ylockchaniis, = np.where(np.abs(y - y0) <= lockr) # convert bool arr to int\n # test Euclid distance from x0, y0 for each ylockchani:\n lockchaniis = ylockchaniis.copy()\n for ylockchanii in ylockchaniis:\n if dist((x[ylockchanii], y[ylockchanii]), (x0, y0)) > lockr:\n # Euclidean distance is too great, remove ylockchanii from lockchaniis:\n lockchaniis = lockchaniis[lockchaniis != ylockchanii]\n lockchans = chans[lockchaniis]\n nlockchans = len(lockchans)\n s['lockchans'][:nlockchans], s['nlockchans'] = lockchans, nlockchans\n print('Spatial localization of spikes took %.3f s' % (time.clock() - tstart))\n\n return nreject\n\n '''\n def get_component_matrix(self, dims=None, weighting=None):\n \"\"\"Convert spike param matrix into pca/ica data for clustering\"\"\"\n\n import mdp # can't delay this any longer\n X = self.get_param_matrix(dims=dims)\n if weighting == None:\n return X\n if weighting.lower() == 'ica':\n node = mdp.nodes.FastICANode()\n elif weighting.lower() == 'pca':\n node = mdp.nodes.PCANode()\n else:\n raise ValueError, 'unknown weighting %r' % weighting\n node.train(X)\n features = node.execute(X) # returns all available components\n #self.node = node\n #self.weighting = weighting\n #self.features = features\n return features\n\n def get_ids(self, cids, spikes):\n \"\"\"Convert a list of cluster ids into 2 dicts: n2sids maps neuron IDs to\n spike IDs; s2nids maps spike IDs to neuron IDs\"\"\"\n cids = np.asarray(cids)\n cids = cids - cids.min() # make sure cluster IDs are 0-based\n uniquecids = set(cids)\n nclusters = len(uniquecids)\n # neuron ID to spike IDs (plural) mapping\n n2sids = dict(zip(uniquecids, [ [] for i in range(nclusters) ]))\n s2nids = {} # spike ID to neuron ID mapping\n for spike, nid in zip(spikes, cids):\n s2nids[spike['id']] = nid\n n2sids[nid].append(spike['id'])\n return n2sids, s2nids\n\n def write_spc_input(self):\n \"\"\"Generate input data file to SPC\"\"\"\n X = self.get_component_matrix()\n # write to space-delimited .dat file. Each row is a spike, each column a param\n spykedir = os.path.dirname(__file__)\n dt = str(datetime.datetime.now())\n dt = dt.split('.')[0] # ditch the us\n dt = dt.replace(' ', '_')\n dt = dt.replace(':', '.')\n self.spcdatfname = os.path.join(spykedir, 'spc', dt+'.dat')\n # not sure why spc adds the dg_01 part:\n self.spclabfname = os.path.join(spykedir, 'spc', dt+'.dg_01.lab')\n f = open(self.spcdatfname, 'w')\n for params in X: # write text data to file, one row at a time\n params.tofile(f, sep=' ', format='%.6f')\n f.write('\\n')\n f.close()\n\n def parse_spc_lab_file(self, fname=None):\n \"\"\"Parse output .lab file from SPC. Each row in the file is the assignment of each\n spin (datapoint) to a cluster, one row per temperature datapoint. First column is\n temperature run number (0-based). 2nd column is the temperature. All remaining\n columns correspond to the datapoints in the order presented in the input .dat file.\n Returns (Ts, cids)\"\"\"\n #spikes = self.get_spikes_sortedby('id')\n if fname == None:\n defaultDir = r\"C:\\Documents and Settings\\Administrator\\Desktop\\Charlie\\From\"\n dlg = wx.FileDialog(None, message=\"Open SPC .lab file\",\n defaultDir=defaultDir, defaultFile='',\n wildcard=\"All files (*.*)|*.*|.lab files (*.lab)|*.lab|\",\n style=wx.OPEN)\n if dlg.ShowModal() == wx.ID_OK:\n fname = dlg.GetPath()\n dlg.Destroy()\n data = np.loadtxt(fname, dtype=np.float32)\n Ts = data[:, 1] # 2nd column\n cids = np.int32(data[:, 2:]) # 3rd column on\n print('Parsed %r' % fname)\n return Ts, cids\n\n def parse_charlies_output(self, fname=None):\n if fname == None:\n fname = (r'C:\\Documents and Settings\\Administrator\\Desktop\\Charlie\\'\n 'From\\2009-07-20\\clustered_events_coiflet_T0.125.txt')\n nids = np.loadtxt(fname, dtype=int) # one neuron id per spike\n return nids\n\n def write_spc_app_input(self):\n \"\"\"Generate input data file to spc_app\"\"\"\n spikes = self.get_spikes_sortedby('id')\n X = self.get_component_matrix()\n # write to tab-delimited data file. Each row is a param, each column a spike\n # (this is the transpose of X)\n # first row has labels \"AFFX\", \"NAME\", and then spike ids\n # first col has labels \"AFFX\", and then param names\n f = open(r'C:\\home\\mspacek\\Desktop\\Work\\SPC\\Weizmann\\spc_app\\spc_app_input.txt', 'w')\n f.write('AFFX\\tNAME\\t')\n for spike in spikes:\n f.write('s%d\\t' % spike['id'])\n f.write('\\n')\n for parami, param in enumerate(['Vpp', 'dt', 'x0', 'y0', 'sx', 'sy', 'theta']):\n f.write(param+'\\t'+param+'\\t')\n for val in X[:, parami]:\n f.write('%f\\t' % val)\n f.write('\\n')\n f.close()\n\n def hcluster(self, t=1.0):\n \"\"\"Hierarchically cluster self.spikes\n\n TODO: consider doing multiple cluster runs. First, cluster by spatial location (x0,\n y0). Then split those clusters up by Vpp. Then those by spatial distrib (sy/sx,\n theta), then by temporal distrib (dt, s1, s2). This will ensure that the lousier\n params will only be considered after the best ones already have, and therefore that\n you start off with pretty good clusters that are then only slightly refined using\n the lousy params\n \"\"\"\n spikes = self.get_spikes_sortedby('id')\n X = self.get_component_matrix()\n print(X)\n # try 'weighted' or 'average' with 'mahalanobis'\n cids = fclusterdata(X, t=t, method='single', metric='euclidean')\n n2sids, s2nids = self.get_ids(cids, spikes)\n return n2sids\n\n def export2Charlie(self, fname='spike_data', onlymaxchan=False, nchans=3, npoints=32):\n \"\"\"Export spike data to a text file, one spike per row.\n Columns are x0, y0, followed by most prominent npoints datapoints\n (1/4, 3/4 wrt spike time) of each nearest nchans. This is to\n give to Charlie to do WPD and SPC on\"\"\"\n if onlymaxchan:\n nchans = 1\n assert np.log2(npoints) % 1 == 0, 'npoints is not a power of 2'\n # get ti - time index each spike is assumed to be centered on\n self.spikes[0].update_wave(self.stream) # make sure it has a wave\n ti = intround(self.spikes[0].wave.data.shape[-1] / 4) # 13 for 50 kHz, 6 for 25 kHz\n dims = self.nspikes, 2+nchans*npoints\n output = np.empty(dims, dtype=np.float32)\n dm = self.detector.dm\n chanis = np.arange(len(dm.data))\n coords = np.asarray(dm.coords)\n xcoords = coords[:, 0]\n ycoords = coords[:, 1]\n sids = list(self.spikes) # self.spikes is a dict!\n sids.sort()\n for sid in sids:\n spike = self.spikes[sid]\n chani = spike.chani # max chani\n x0, y0 = spike.x0, spike.y0\n if onlymaxchan:\n nearestchanis = np.asarray([chani])\n else:\n # find closest chans to x0, y0\n d2s = (xcoords - x0)**2 + (ycoords - y0)**2 # squared distances\n sortis = d2s.argsort()\n nearestchanis = chanis[sortis][0:nchans] # pick the first nchan nearest chans\n if chani not in nearestchanis:\n print(\"WARNING: max chani %d is not among the %d chanis nearest \"\n \"(x0, y0) = (%.1f, %.1f) for spike %d at t=%d\"\n % (chani, nchans, x0, y0, sid, spike.t))\n if spike.wave.data is None:\n spike.update_wave(self.stream)\n row = [x0, y0]\n for chani in nearestchanis:\n chan = dm.chans[chani] # dereference\n try:\n data = spike.wave[chan].data[0] # pull out singleton dimension\n except IndexError: # empty array\n data = np.zeros(data.shape[-1], data.dtype)\n row.extend(data[ti-npoints/4:ti+npoints*3/4])\n output[sid] = row\n dt = str(datetime.datetime.now())\n dt = dt.split('.')[0] # ditch the us\n dt = dt.replace(' ', '_')\n dt = dt.replace(':', '.')\n fname += '.' + dt + '.txt'\n np.savetxt(fname, output, fmt='%.1f', delimiter=' ')\n\n def match(self, templates=None, weighting='signal', sort=True):\n \"\"\"Match templates to all .spikes with nearby maxchans,\n save error values to respective templates.\n\n Note: slowest step by far is loading in the wave data from disk.\n (First match is slow, subsequent ones are ~ 15X faster.)\n Unless something's done about that in advance, don't bother optimizing here much.\n Right now, once waves are loaded, performance is roughly 20000 matches/sec\n\n TODO: Nick's alternative to gaussian distance weighting: have two templates: a mean\n template, and an stdev template, and weight the error between each matched\n spike and the mean on each chan at each timepoint by the corresponding stdev value\n (divide the error by the stdev, so that timepoints with low stdev are more sensitive\n to error)\n\n TODO: looks like I still need to make things more nonlinear - errors at high signal\n values aren't penalized enough, while errors at small signal values are penalized\n too much. Try cubing both signals, then taking sum(err**2)\n\n DONE: maybe even better, instead of doing an elaborate cubing of signal, followed by\n a rather elaborate gaussian spatiotemporal weighting of errors, just take difference\n of signals, and weight the error according to the abs(template_signal) at each point\n in time and across chans. That way, error in parts of the signal far from zero are\n considered more important than deviance of perhaps similar absolute value for signal\n close to zero\n\n \"\"\"\n # None defaults to matching all templates:\n templates = templates or self.templates.values()\n sys.stdout.write('matching')\n t0 = time.time()\n nspikes = len(self.spikes)\n dm = self.detector.dm\n for template in templates:\n template.err = [] # overwrite any existing .err attrib\n tw = template.tw\n templatewave = template.wave[template.chans] # pull out template's enabled chans\n #stdev = template.get_stdev()[template.chans] # pull out template's enabled chans\n # replace any 0s with 1s - TODO: what's best way to avoid singularities?:\n #stdev[stdev == 0] = 1\n # Gaussian weighting in space and/or time:\n weights = template.get_weights(weighting=weighting, sstdev=self.detector.slock/2,\n tstdev=self.detector.tlock/2)\n for spike in self.spikes.values():\n # check if spike.maxchan is outside some minimum distance from template.maxchan\n if dm[template.maxchan, spike.maxchan] > MAXCHANTOLERANCE: # um\n continue # don't even bother\n if spike.wave.data is None or template.tw != TW: # make sure their data line up\n spike.update_wave(tw) # this slows things down a lot, but is necessary\n # slice template's enabled chans out of spike, calculate sum of\n # squared weighted error\n # first impression is that dividing by stdev makes separation worse, not better\n # low stdev means more sensitive to error:\n #err = (templatewave.data - spike.wave[template.chans].data) / stdev * weights\n # pull out template's enabled chans from spike:\n spikewave = spike.wave[template.chans]\n if weighting == 'signal':\n tsdata = np.asarray([templatewave.data, spikewave.data])\n # take elementwise max of abs of template and spike data:\n weights = np.abs(tsdata).max(axis=0)\n err = (templatewave.data - spikewave.data) * weights # weighted error\n err = (err**2).sum(axis=None) # sum of squared weighted error\n template.err.append((spike.id, intround(err)))\n template.err = np.asarray(template.err, dtype=np.int64)\n if sort and len(template.err) != 0:\n i = template.err[:, 1].argsort() # row indices that sort by error\n template.err = template.err[i]\n sys.stdout.write('.')\n print('\\nmatch took %.3f sec' % (time.time()-t0))\n '''\n\nclass Neuron(object):\n \"\"\"A collection of spikes that have been deemed somehow, whether manually\n or automatically, to have come from the same cell. A Neuron's waveform\n is the mean of its member spikes\"\"\"\n def __init__(self, sort, id=None):\n self.sort = sort\n self.id = id # neuron id\n self.wave = WaveForm() # init to empty waveform\n self.sids = np.array([], dtype=int) # indices of spikes that make up this neuron\n # relative reference timestamp, here for symmetry with fellow spike rec\n # (obj.t comes up sometimes):\n self.t = 0\n self.plt = None # Plot currently holding self\n self.cluster = None\n self.good = False # user can mark this neuron as \"good\" if so desired\n #self.fname # not here, let's allow neurons to have spikes from different files?\n\n def get_chans(self):\n if self.wave.data is None:\n self.update_wave()\n return self.wave.chans # self.chans just refers to self.wave.chans\n\n chans = property(get_chans)\n\n def get_chan(self):\n if self.wave.data is None:\n self.update_wave()\n return self.wave.chans[self.wave.data.ptp(axis=1).argmax()] # chan with max Vpp\n\n chan = property(get_chan)\n\n def get_nspikes(self):\n return len(self.sids)\n\n nspikes = property(get_nspikes)\n\n def __getstate__(self):\n \"\"\"Get object state for pickling\"\"\"\n d = self.__dict__.copy()\n # don't save any calculated PCs/ICs:\n #d.pop('X', None)\n #d.pop('Xhash', None)\n # don't save plot self is assigned to, since that'll change anyway on unpickle\n d['plt'] = None\n return d\n\n def get_wave(self):\n \"\"\"Check for valid mean and std waveform before returning it\"\"\"\n # many neuron waveforms saved in old .sort files won't have a wave.std field:\n try:\n self.wave.std\n except AttributeError:\n return self.update_wave()\n if self.wave == None or self.wave.data is None or self.wave.std is None:\n return self.update_wave()\n else:\n return self.wave # return existing waveform\n\n def update_wave(self):\n \"\"\"Update mean and std of self's waveform\"\"\"\n sort = self.sort\n spikes = sort.spikes\n if len(self.sids) == 0: # no member spikes, perhaps I should be deleted?\n raise RuntimeError(\"n%d has no spikes and its waveform can't be updated\" % self.id)\n meanwave = sort.get_mean_wave(self.sids, nid=self.id)\n\n # update self's Waveform object\n self.wave.data = meanwave.data\n self.wave.std = meanwave.std\n self.wave.ts = sort.twts.copy() # meanwave has no .ts, copy for clean jsonpickle\n self.wave.chans = meanwave.chans\n self.wave.tres = sort.tres # meanwave has no .tres\n return self.wave\n\n def __sub__(self, other):\n \"\"\"Return difference array between self and other neurons' waveforms\n on common channels\"\"\"\n selfwavedata, otherwavedata = self.getCommonWaveData(other.chan, other.chans,\n other.wave.data)\n return selfwavedata - otherwavedata\n\n def getCommonWaveData(self, otherchan, otherchans, otherwavedata):\n \"\"\"Return waveform data common to self's chans and otherchans, while\n requiring that both include the other's maxchan\"\"\"\n chans = np.intersect1d(self.chans, otherchans, assume_unique=True)\n if len(chans) == 0:\n raise ValueError('No common chans')\n if self.chan not in chans or otherchan not in chans:\n raise ValueError(\"maxchans aren't part of common chans\")\n selfchanis = self.chans.searchsorted(chans)\n otherchanis = otherchans.searchsorted(chans)\n return self.wave.data[selfchanis], otherwavedata[otherchanis]\n '''\n def get_stdev(self):\n \"\"\"Return 2D array of stddev of each timepoint of each chan of member spikes.\n Assumes self.update_wave has already been called\"\"\"\n data = []\n # TODO: speed this up by pre-allocating memory and then filling in the array\n for spike in self.spikes:\n data.append(spike.wave.data) # collect spike's data\n stdev = np.asarray(data).std(axis=0)\n return stdev\n\n def get_weights(self, weighting=None, sstdev=None, tstdev=None):\n \"\"\"Returns unity, spatial, temporal, or spatiotemporal Gaussian weights\n for self's enabled chans in self.wave.data, given spatial and temporal\n stdevs\"\"\"\n nchans = len(self.wave.chans)\n nt = len(self.wave.data[0]) # assume all chans have the same number of timepoints\n if weighting == None:\n weights = 1\n elif weighting == 'spatial':\n weights = self.get_gaussian_spatial_weights(sstdev) # vector\n elif weighting == 'temporal':\n weights = self.get_gaussian_temporal_weights(tstdev) # vector\n elif weighting == 'spatiotemporal':\n sweights = self.get_gaussian_spatial_weights(sstdev)\n tweights = self.get_gaussian_temporal_weights(tstdev)\n weights = np.outer(sweights, tweights) # matrix, outer product of the two\n elif weighting == 'signal':\n weights = None # this is handled by caller\n #print('\\nweights:\\n%r' % weights)\n return weights\n\n def get_gaussian_spatial_weights(self, stdev):\n \"\"\"Return a vector that weights self.chans according to a 2D gaussian\n centered on self.maxchan with standard deviation stdev in um\"\"\"\n g = Gaussian(mean=0, stdev=stdev)\n # distances between maxchan and all enabled chans:\n d = self.sort.detector.dm[self.maxchan, self.chans]\n weights = g[d]\n weights.shape = (-1, 1) # vertical vector with nchans rows, 1 column\n return weights\n\n def get_gaussian_temporal_weights(self, stdev):\n \"\"\"Return a vector that weights timepoints in self's mean waveform\n by a gaussian centered on t=0, with standard deviation stdev in us\"\"\"\n g = Gaussian(mean=0, stdev=stdev)\n ts = self.wave.ts # template mean timepoints relative to t=0 spike time\n weights = g[ts] # horizontal vector with 1 row, nt timepoints\n return weights\n '''\n\nclass PTCSHeader(object):\n \"\"\"\n Polytrode clustered spikes file header:\n\n formatversion: int64 (currently version 3)\n ndescrbytes: uint64 (nbytes, keep as multiple of 8 for nice alignment)\n descr: ndescrbytes of ASCII text\n (padded with null bytes if needed for 8 byte alignment)\n\n nneurons: uint64 (number of neurons)\n nspikes: uint64 (total number of spikes)\n nsamplebytes: uint64 (number of bytes per template waveform sample)\n samplerate: uint64 (Hz)\n\n npttypebytes: uint64 (nbytes, keep as multiple of 8 for nice alignment)\n pttype: npttypebytes of ASCII text\n (padded with null bytes if needed for 8 byte alignment)\n nptchans: uint64 (total num chans in polytrode)\n chanpos: nptchans * 2 * float64\n (array of (x, y) positions, in um, relative to top of polytrode,\n indexed by 0-based channel IDs)\n nsrcfnamebytes: uint64 (nbytes, keep as multiple of 8 for nice alignment)\n srcfname: nsrcfnamebytes of ASCII text\n (source file name, probably .srf, padded with null bytes if needed for\n 8 byte alignment)\n datetime: float64\n (absolute datetime corresponding to t=0 us timestamp, stored as days since\n epoch: December 30, 1899 at 00:00)\n ndatetimestrbytes: uint64 \n datetimestr: ndatetimestrbytes of ASCII text\n (human readable string representation of datetime, preferrably ISO 8601,\n padded with null bytes if needed for 8 byte alignment)\n \"\"\"\n FORMATVERSION = 3 # overall .ptcs file format version, not header format version\n def __init__(self, sort, sortpath, stream, nneurons, nspikes, nsamplebytes,\n fullfname, exportdt, user='', notes=''):\n self.sort = sort\n self.stream = stream\n self.nneurons = nneurons\n self.nspikes = nspikes\n self.nsamplebytes = nsamplebytes\n homelessfullfname = lstrip(fullfname, os.path.expanduser('~'))\n sortfname = sort.fname\n sortfullfname = os.path.join(sortpath, sortfname)\n sortfmoddt = str(datetime.datetime.fromtimestamp(os.path.getmtime(sortfullfname)))\n sortfmoddt = sortfmoddt.split('.')[0] # ditch the us\n sortfsize = os.path.getsize(sortfullfname) # in bytes\n d = {'file_type': '.ptcs (polytrode clustered spikes) file',\n 'original_fname': homelessfullfname, 'export_time': exportdt,\n 'sort': {'fname': sortfname, 'path': sortpath,\n 'fmtime': sortfmoddt, 'fsize': sortfsize},\n 'user': user, 'notes': notes}\n descr = str(d)\n self.descr = pad(descr, align=8)\n self.srcfname = pad(lstrip(stream.fname, '../'), align=8)\n self.pttype = pad(stream.probe.name, align=8)\n self.dt = stream.datetime\n self.dtstr = pad(self.dt.isoformat(), align=8)\n\n def write(self, f):\n s = self.sort\n np.int64(self.FORMATVERSION).tofile(f) # formatversion\n np.uint64(len(self.descr)).tofile(f) # ndescrbytes\n f.write(self.descr) # descr\n \n np.uint64(self.nneurons).tofile(f) # nneurons\n np.uint64(self.nspikes).tofile(f) # nspikes\n np.uint64(self.nsamplebytes).tofile(f) # nsamplebytes\n np.uint64(s.sampfreq).tofile(f) # samplerate\n\n np.uint64(len(self.pttype)).tofile(f) # npttypebytes\n f.write(self.pttype) # pttype\n np.uint64(s.stream.probe.nchans).tofile(f) # nptchans\n np.float64(s.stream.probe.siteloc_arr()).tofile(f) # chanpos\n np.uint64(len(self.srcfname)).tofile(f) # nsrcfnamebytes\n f.write(self.srcfname) # srcfname\n np.float64(td2days(self.dt - EPOCH)).tofile(f) # datetime (in days)\n np.uint64(len(self.dtstr)).tofile(f) # ndatetimestrbytes\n f.write(self.dtstr)\n\n\nclass PTCSNeuronRecord(object):\n \"\"\"\n Polytrode clustered spikes file neuron record:\n \n nid: int64 (signed neuron id, could be -ve, could be non-contiguous with previous)\n ndescrbytes: uint64 (nbytes, keep as multiple of 8 for nice alignment, defaults to 0)\n descr: ndescrbytes of ASCII text\n (padded with null bytes if needed for 8 byte alignment)\n clusterscore: float64\n xpos: float64 (um)\n ypos: float64 (um)\n sigma: float64 (um) (Gaussian spatial sigma)\n nchans: uint64 (num chans in template waveforms)\n chanids: nchans * uint64 (0 based IDs of channels in template waveforms)\n maxchanid: uint64 (0 based ID of max channel in template waveforms)\n nt: uint64 (num timepoints per template waveform channel)\n nwavedatabytes: uint64 (nbytes, keep as multiple of 8 for nice alignment)\n wavedata: nwavedatabytes of nsamplebytes sized floats\n (template waveform data, laid out as nchans * nt, in uV,\n padded with null bytes if needed for 8 byte alignment)\n nwavestdbytes: uint64 (nbytes, keep as multiple of 8 for nice alignment)\n wavestd: nwavestdbytes of nsamplebytes sized floats\n (template waveform standard deviation, laid out as nchans * nt, in uV,\n padded with null bytes if needed for 8 byte alignment)\n nspikes: uint64 (number of spikes in this neuron)\n spike timestamps: nspikes * uint64 (us, should be sorted)\n \"\"\"\n def __init__(self, neuron, spikets=None, nsamplebytes=None, descr=''):\n n = neuron\n AD2uV = n.sort.converter.AD2uV\n self.neuron = neuron\n self.spikets = spikets # constrained to stream range, may be < neuron.sids\n self.wavedtype = {2: np.float16, 4: np.float32, 8: np.float64}[nsamplebytes]\n if n.wave.data is None or n.wave.std is None: # some may have never been displayed\n n.update_wave()\n # wavedata and wavestd are nchans * nt * nsamplebytes long:\n self.wavedata = pad(self.wavedtype(AD2uV(n.wave.data)), align=8)\n self.wavestd = pad(self.wavedtype(AD2uV(n.wave.std)), align=8)\n self.descr = pad(descr, align=8)\n \n def write(self, f):\n n = self.neuron\n np.int64(n.id).tofile(f) # nid\n np.uint64(len(self.descr)).tofile(f) # ndescrbytes\n f.write(self.descr) # descr, bytes\n np.float64(np.nan).tofile(f) # clusterscore\n np.float64(n.cluster.pos['x0']).tofile(f) # xpos (um)\n np.float64(n.cluster.pos['y0']).tofile(f) # ypos (um)\n np.float64(n.cluster.pos['sx']).tofile(f) # sigma (um)\n np.uint64(len(n.wave.chans)).tofile(f) # nchans\n np.uint64(n.wave.chans).tofile(f) # chanids\n np.uint64(n.chan).tofile(f) # maxchanid\n np.uint64(len(n.wave.ts)).tofile(f) # nt\n np.uint64(self.wavedata.nbytes).tofile(f) # nwavedatabytes\n self.wavedata.tofile(f) # wavedata \n np.uint64(self.wavestd.nbytes).tofile(f) # nwavestdbytes\n self.wavestd.tofile(f) # wavestd \n np.uint64(len(self.spikets)).tofile(f) # nspikes\n np.uint64(self.spikets).tofile(f) # spike timestamps (us)\n\n\nclass PanelScrollArea(QtGui.QScrollArea):\n \"\"\"A scroll area for the spikesortpanel\"\"\"\n def keyPressEvent(self, event):\n key = event.key()\n # seems the ENTER key needs be handled to directly call plot, unlike in sortwin\n # where the event is passed on to be handled by the list widgets\n if key in [Qt.Key_Enter, Qt.Key_Return]:\n sortwin = self.topLevelWidget()\n sortwin.parent().ui.plotButton.click()\n else:\n QtGui.QScrollArea.keyPressEvent(self, event) # pass it on\n\n\nclass SortWindow(SpykeToolWindow):\n \"\"\"Sort window\"\"\"\n def __init__(self, parent, pos=None):\n SpykeToolWindow.__init__(self, parent, flags=QtCore.Qt.Tool)\n self.spykewindow = parent\n ncols = self.sort.probe.ncols\n nrows = self.sort.probe.nrows\n # try and allow the same amount of horizontal space per column for 2 and 3 col probes:\n if ncols <= 2:\n self.MAINSPLITTERPOS = 300\n else:\n self.MAINSPLITTERPOS = 265 # move it more to the left\n # make horizontal sort slider use as little vertical space as possible\n self.VSPLITTERPOS = 1\n panelwidth = PANELWIDTHPERCOLUMN * ncols\n panelheight = PANELHEIGHTPERROW * nrows\n width = max(self.MAINSPLITTERPOS + panelwidth + VSCROLLBARWIDTH, MINSORTWINDOWWIDTH)\n size = (width, SORTWINDOWHEIGHT)\n self.setWindowTitle('Sort Window')\n self.move(*pos)\n self.resize(*size)\n\n self._source = None # source cluster for comparison\n self.slider = SpikeSelectionSlider(Qt.Horizontal, self)\n self.slider.setInvertedControls(True)\n self.slider.setToolTip('Position of sliding spike selection time window')\n self.connect(self.slider, QtCore.SIGNAL('valueChanged(int)'),\n self.on_slider_valueChanged)\n self.connect(self.slider, QtCore.SIGNAL('sliderPressed()'),\n self.on_slider_sliderPressed)\n\n self.nlist = NList(self)\n self.nlist.setToolTip('Neuron list')\n self.nslist = NSList(self)\n self.nslist.setToolTip('Sorted spike list')\n self.uslist = USList(self) # should really be multicolumn tableview\n self.uslist.setToolTip('Unsorted spike list')\n tw = self.spykewindow.sort.tw\n\n self.panel = SpikeSortPanel(self, tw=tw)\n self.panel.setMinimumSize(QtCore.QSize(panelwidth, panelheight))\n\n self.panelscrollarea = PanelScrollArea(self)\n self.panelscrollarea.setWidget(self.panel)\n self.panelscrollarea.setMinimumWidth(panelwidth + VSCROLLBARWIDTH)\n self.panelscrollarea.setWidgetResizable(True) # allows panel to size bigger than min\n\n self.vsplitter = QtGui.QSplitter(Qt.Vertical)\n self.vsplitter.addWidget(self.slider)\n self.vsplitter.addWidget(self.nlist)\n self.vsplitter.addWidget(self.nslist)\n self.vsplitter.addWidget(self.uslist)\n\n self.mainsplitter = QtGui.QSplitter(Qt.Horizontal)\n self.mainsplitter.addWidget(self.vsplitter)\n self.mainsplitter.addWidget(self.panelscrollarea)\n\n self.layout = QtGui.QVBoxLayout()\n self.layout.setContentsMargins(0, 0, 0, 0)\n self.layout.addWidget(self.mainsplitter)\n\n mainwidget = QtGui.QWidget(self)\n mainwidget.setLayout(self.layout)\n self.setCentralWidget(mainwidget)\n\n self.toolbar = self.setupToolbar()\n self.addToolBar(self.toolbar)\n\n def setupToolbar(self):\n toolbar = QtGui.QToolBar(self)\n toolbar.setObjectName('toolbar')\n toolbar.setFloatable(True)\n toolbar.setIconSize(QtCore.QSize(16, 16)) # like in main spyke window\n\n actionDelete = QAction(QIcon('res/edit-delete.svg'), 'Del', self)\n tt = ('<nobr><b>Del</b> Delete selected spikes or clusters</nobr>\\n'\n '<nobr><b>CTRL+Del</b> Delete selected spikes</nobr>')\n actionDelete.setToolTip(tt)\n self.connect(actionDelete, QtCore.SIGNAL('triggered()'),\n self.on_actionDelete_triggered)\n toolbar.addAction(actionDelete)\n\n actionMergeClusters = QAction('M', self)\n tt = '<nobr><b>M</b> Merge clusters</nobr>'\n actionMergeClusters.setToolTip(tt)\n self.connect(actionMergeClusters, QtCore.SIGNAL('triggered()'),\n self.on_actionMergeClusters_triggered)\n toolbar.addAction(actionMergeClusters)\n\n #actionToggleClustersGood = QAction(QIcon('res/dialog-apply.svg'), 'G', self)\n actionToggleClustersGood = QAction('G', self)\n tt = '<nobr><b>G</b> Toggle clusters as \"good\"</nobr>'\n actionToggleClustersGood.setToolTip(tt)\n self.connect(actionToggleClustersGood, QtCore.SIGNAL('triggered()'),\n self.on_actionToggleClustersGood_triggered)\n toolbar.addAction(actionToggleClustersGood)\n\n actionSplit = QAction('+', self)\n tt = '<nobr><b>+</b> Split off selected spikes</nobr>'\n actionSplit.setToolTip(tt)\n self.connect(actionSplit, QtCore.SIGNAL('triggered()'),\n self.on_actionSplit_triggered)\n toolbar.addAction(actionSplit)\n\n actionLabelMultiunit = QAction('-', self)\n tt = '<nobr><b>-</b> Label clusters as multiunit</nobr>'\n actionLabelMultiunit.setToolTip(tt)\n self.connect(actionLabelMultiunit, QtCore.SIGNAL('triggered()'),\n self.on_actionLabelMultiunit_triggered)\n toolbar.addAction(actionLabelMultiunit)\n\n actionChanSplitClusters = QAction('/', self)\n tt = '<nobr><b>/</b> Split clusters by channels</nobr>'\n actionChanSplitClusters.setToolTip(tt)\n self.connect(actionChanSplitClusters, QtCore.SIGNAL('triggered()'),\n self.on_actionChanSplitClusters_triggered)\n toolbar.addAction(actionChanSplitClusters)\n\n actionDensitySplit = QAction('P', self)\n tt = ('<nobr><b>P</b> Split cluster pair by density along line between '\n 'their centers</nobr>')\n actionDensitySplit.setToolTip(tt)\n self.connect(actionDensitySplit, QtCore.SIGNAL('triggered()'),\n self.on_actionDensitySplit_triggered)\n toolbar.addAction(actionDensitySplit)\n\n actionRandomSplit = QAction('\\\\', self)\n tt = ('<nobr><b>\\\\</b> Randomly split each selected cluster in half</nobr>')\n actionRandomSplit.setToolTip(tt)\n self.connect(actionRandomSplit, QtCore.SIGNAL('triggered()'),\n self.on_actionRandomSplit_triggered)\n toolbar.addAction(actionRandomSplit)\n\n #actionRenumber = QAction(QIcon('res/gtk-edit.svg'), '#', self)\n actionRenumber = QAction('#', self)\n tt = ('<nobr><b>#</b> Renumber all clusters in vertical spatial order</nobr>\\n'\n '<nobr><b>CTRL+#</b> Renumber selected cluster</nobr>')\n actionRenumber.setToolTip(tt)\n self.connect(actionRenumber, QtCore.SIGNAL('triggered()'),\n self.on_actionRenumber_triggered)\n toolbar.addAction(actionRenumber)\n\n actionFind = QAction(QIcon('res/edit-find.svg'), 'Find', self)\n tt = ('<nobr><b>CTRL+F</b> Find spike in cluster plot</nobr>')\n actionFind.setToolTip(tt)\n self.connect(actionFind, QtCore.SIGNAL('triggered()'),\n self.on_actionFind_triggered)\n toolbar.addAction(actionFind)\n\n actionSelectRandomSpikes = QAction('R', self)\n tt = '<nobr><b>R</b> Select random sample of spikes of current clusters</nobr>'\n actionSelectRandomSpikes.setToolTip(tt)\n self.connect(actionSelectRandomSpikes, QtCore.SIGNAL('triggered()'),\n self.on_actionSelectRandomSpikes_triggered)\n toolbar.addAction(actionSelectRandomSpikes)\n\n actionToggleErrors = QAction('E', self)\n actionToggleErrors.setCheckable(True)\n actionToggleErrors.setChecked(self.panel.enable_fills)\n tt = '<nobr><b>CTRL+E</b> Toggle visibility of template error limits</nobr>'\n actionToggleErrors.setToolTip(tt)\n self.connect(actionToggleErrors, QtCore.SIGNAL('toggled(bool)'),\n self.on_actionToggleErrors_toggled)\n toolbar.addAction(actionToggleErrors)\n self.actionToggleErrors = actionToggleErrors\n\n nsamplesComboBox = QtGui.QComboBox(self)\n nsamplesComboBox.setToolTip('Number of spikes per cluster to randomly select')\n nsamplesComboBox.setFocusPolicy(Qt.NoFocus)\n nsamplesComboBox.addItems(['100', '50', '20', '10', '5', '1'])\n nsamplesComboBox.setCurrentIndex(2)\n toolbar.addWidget(nsamplesComboBox)\n self.connect(nsamplesComboBox, QtCore.SIGNAL('activated(int)'),\n self.on_actionSelectRandomSpikes_triggered)\n self.nsamplesComboBox = nsamplesComboBox\n\n gainComboBox = QtGui.QComboBox(self)\n gainComboBox.setToolTip('Waveform gain (default: 1.5)')\n gainComboBox.setFocusPolicy(Qt.NoFocus)\n gainComboBox.addItems(['4', '3.75', '3.5', '3.25', '3', '2.75', '2.5', '2.25', '2',\n '1.75', '1.5', '1.25', '1', '0.75', '0.5', '0.25'])\n gainComboBox.setCurrentIndex(3)\n toolbar.addWidget(gainComboBox)\n self.connect(gainComboBox, QtCore.SIGNAL('activated(int)'),\n self.on_gainComboBox_triggered)\n self.gainComboBox = gainComboBox\n\n #actionAlignMin = QAction(QIcon('res/go-bottom.svg'), 'Min', self)\n actionAlignMin = QAction('Min', self)\n actionAlignMin.setToolTip('Align selected spikes to min')\n self.connect(actionAlignMin, QtCore.SIGNAL('triggered()'),\n self.on_actionAlignMin_triggered)\n toolbar.addAction(actionAlignMin)\n\n #actionAlignMax = QAction(QIcon('res/go-top.svg'), 'Max', self)\n actionAlignMax = QAction('Max', self)\n actionAlignMax.setToolTip('Align selected spikes to max')\n self.connect(actionAlignMax, QtCore.SIGNAL('triggered()'),\n self.on_actionAlignMax_triggered)\n toolbar.addAction(actionAlignMax)\n\n #actionAlignBest = QAction(QIcon('res/emblem-OK.png'), 'Best', self)\n actionAlignBest = QAction('B', self)\n tt = '<nobr><b>B</b> Align selected spikes by best fit</nobr>'\n actionAlignBest.setToolTip(tt)\n self.connect(actionAlignBest, QtCore.SIGNAL('triggered()'),\n self.on_actionAlignBest_triggered)\n toolbar.addAction(actionAlignBest)\n\n actionShiftLeft = QAction('[', self)\n tt = ('<nobr><b>[</b> Shift selected spikes 2 points left</nobr>\\n'\n '<nobr><b>CTRL+[</b> Shift selected spikes 1 point left</nobr>')\n actionShiftLeft.setToolTip(tt)\n self.connect(actionShiftLeft, QtCore.SIGNAL('triggered()'),\n self.on_actionShiftLeft_triggered)\n toolbar.addAction(actionShiftLeft)\n\n actionShiftRight = QAction(']', self)\n tt = ('<nobr><b>]</b> Shift selected spikes 2 points right</nobr>\\n'\n '<nobr><b>CTRL+]</b> Shift selected spikes 1 point right</nobr>')\n actionShiftRight.setToolTip(tt)\n self.connect(actionShiftRight, QtCore.SIGNAL('triggered()'),\n self.on_actionShiftRight_triggered)\n toolbar.addAction(actionShiftRight)\n\n incltComboBox = QtGui.QComboBox(self)\n incltComboBox.setToolTip(\"Waveform duration (us) to include for component \"\n \"analysis,\\nasymmetric around spike time\")\n incltComboBox.setFocusPolicy(Qt.NoFocus)\n dtw = self.sort.tw[1] - self.sort.tw[0] # spike time window width\n incltstep = intround(dtw / 10) # evenly spaced inclt values\n incltvals = np.arange(dtw, 0, -incltstep)\n incltComboBox.addItems([ str(incltval) for incltval in incltvals ])\n incltComboBox.setCurrentIndex(0)\n toolbar.addWidget(incltComboBox)\n self.connect(incltComboBox, QtCore.SIGNAL('activated(int)'),\n self.on_incltComboBox_triggered)\n self.incltComboBox = incltComboBox\n #incltunitsLabel = QtGui.QLabel('us', self)\n #toolbar.addWidget(incltunitsLabel)\n\n nPCsPerChanSpinBox = QtGui.QSpinBox(self)\n nPCsPerChanSpinBox.setToolTip(\"Number of PCs to use per channel to feed into ICA\")\n nPCsPerChanSpinBox.setFocusPolicy(Qt.NoFocus)\n toolbar.addWidget(nPCsPerChanSpinBox)\n nPCsPerChanSpinBox.setMinimum(1)\n self.connect(nPCsPerChanSpinBox, QtCore.SIGNAL('valueChanged(int)'),\n self.on_nPCsPerChanSpinBox_valueChanged)\n nPCsPerChanSpinBox.setValue(self.sort.npcsperchan)\n self.nPCsPerChanSpinBox = nPCsPerChanSpinBox\n\n #actionFindPrevMostSimilar = QAction(QIcon('res/go-previous.svg'), '<', self)\n actionFindPrevMostSimilar = QAction('<', self)\n tt = '<nobr><b><</b> Find previous most similar cluster</nobr>'\n actionFindPrevMostSimilar.setToolTip(tt)\n self.connect(actionFindPrevMostSimilar, QtCore.SIGNAL('triggered()'),\n self.on_actionFindPrevMostSimilar_triggered)\n toolbar.addAction(actionFindPrevMostSimilar)\n\n #actionFindNextMostSimilar = QAction(QIcon('res/go-next.svg'), '>', self)\n actionFindNextMostSimilar = QAction('>', self)\n tt = '<nobr><b>></b> Find next most similar cluster</nobr>'\n actionFindNextMostSimilar.setToolTip(tt)\n self.connect(actionFindNextMostSimilar, QtCore.SIGNAL('triggered()'),\n self.on_actionFindNextMostSimilar_triggered)\n toolbar.addAction(actionFindNextMostSimilar)\n\n actionReloadSpikes = QAction(QIcon('res/view-refresh.svg'), 'Reload', self)\n tt = ('<nobr><b>F5</b> Reload waveforms of selected spikes. '\n 'If none selected, reload all</nobr>\\n'\n '<nobr><b>CTRL+F5</b> Use mean waveform to choose chans to reload</nobr>')\n actionReloadSpikes.setToolTip(tt)\n self.connect(actionReloadSpikes, QtCore.SIGNAL('triggered()'),\n self.on_actionReloadSpikes_triggered)\n toolbar.addAction(actionReloadSpikes)\n\n actionSave = QAction(QIcon('res/document-save.svg'), '&Save', self)\n actionSave.setToolTip('Save sort panel to file')\n self.connect(actionSave, QtCore.SIGNAL('triggered()'),\n self.on_actionSave_triggered)\n toolbar.addAction(actionSave)\n\n return toolbar\n\n def get_sort(self):\n return self.spykewindow.sort\n\n sort = property(get_sort) # make this a property for proper behaviour after unpickling\n\n def closeEvent(self, event):\n self.spykewindow.HideWindow('Sort')\n\n def mousePressEvent(self, event):\n \"\"\"These are mostly passed on up from spyke list views and sort panel. Left\n clicks are (or should be) filtered out\"\"\"\n buttons = event.buttons()\n if buttons == QtCore.Qt.MiddleButton:\n #self.on_actionSelectRandomSpikes_triggered()\n self.spykewindow.ui.plotButton.click() # same as hitting ENTER in nslist\n elif buttons == QtCore.Qt.RightButton:\n self.clear()\n\n def keyPressEvent(self, event):\n \"\"\"Alpha character keypresses are by default caught by the child lists for quickly\n scrolling down to and selecting list items. However, the appropriate alpha\n keypresses have been set in the child lists to be ignored, so they propagate\n up to here\"\"\"\n key = event.key()\n modifiers = event.modifiers()\n ctrl = modifiers & Qt.ControlModifier # ctrl is down\n spw = self.spykewindow\n if key == Qt.Key_A: # ignored in SpykeListViews\n spw.ui.plotButton.click() # same as hitting ENTER in nslist\n elif key == Qt.Key_X: # ignored in SpykeListViews\n spw.ui.plotXcorrsButton.click()\n elif key == Qt.Key_N: # ignored in SpykeListViews\n spw.ui.normButton.click()\n elif key == Qt.Key_Escape: # deselect all spikes and all clusters\n self.clear()\n elif key == Qt.Key_Delete:\n self.on_actionDelete_triggered()\n elif key == Qt.Key_M: # ignored in SpykeListViews\n self.on_actionMergeClusters_triggered()\n elif key == Qt.Key_G: # ignored in SpykeListViews\n self.on_actionToggleClustersGood_triggered()\n elif key == Qt.Key_Equal: # ignored in SpykeListViews\n self.on_actionSplit_triggered()\n elif key == Qt.Key_Minus: # ignored in SpykeListViews\n self.on_actionLabelMultiunit_triggered()\n elif key == Qt.Key_Slash: # ignored in SpykeListViews\n self.on_actionChanSplitClusters_triggered()\n elif key == Qt.Key_P: # ignored in SpykeListViews\n self.on_actionDensitySplit_triggered()\n elif key == Qt.Key_Backslash: # ignored in SpykeListViews\n self.on_actionRandomSplit_triggered()\n elif key == Qt.Key_NumberSign: # ignored in SpykeListViews\n self.on_actionRenumber_triggered()\n elif key == Qt.Key_F: # ignored in SpykeListViews\n if ctrl:\n self.FindSpike()\n else:\n self.FindCluster()\n elif key == Qt.Key_R: # ignored in SpykeListViews\n self.on_actionSelectRandomSpikes_triggered()\n elif key == Qt.Key_Space: # ignored in SpykeListViews\n if ctrl:\n SpykeToolWindow.keyPressEvent(self, event) # pass it on\n else:\n spw.on_clusterButton_clicked()\n elif key == Qt.Key_B: # ignored in SpykeListViews\n self.on_actionAlignBest_triggered()\n elif key == Qt.Key_BracketLeft: # ignored in SpykeListViews\n self.on_actionShiftLeft_triggered()\n elif key == Qt.Key_BracketRight: # ignored in SpykeListViews\n self.on_actionShiftRight_triggered()\n elif key == Qt.Key_Comma: # ignored in SpykeListViews\n self.on_actionFindPrevMostSimilar_triggered()\n elif key == Qt.Key_Period: # ignored in SpykeListViews\n self.on_actionFindNextMostSimilar_triggered()\n elif key == Qt.Key_F5: # ignored in SpykeListViews\n self.on_actionReloadSpikes_triggered()\n elif key == Qt.Key_E: # ignored in SpykeListViews\n if ctrl:\n self.actionToggleErrors.toggle()\n else:\n self.clear() # E is synonymous with ESC\n elif key == Qt.Key_C: # toggle between PCA and ICA, ignored in SpykeListViews\n c = str(spw.ui.componentAnalysisComboBox.currentText())\n if c == 'PCA':\n index = spw.ui.componentAnalysisComboBox.findText('ICA')\n spw.ui.componentAnalysisComboBox.setCurrentIndex(index)\n elif c == 'ICA':\n index = spw.ui.componentAnalysisComboBox.findText('PCA')\n spw.ui.componentAnalysisComboBox.setCurrentIndex(index)\n spw.on_plotButton_clicked()\n elif key == Qt.Key_T: # toggle plotting against time, ignored in SpykeListViews\n z = str(spw.ui.zDimComboBox.currentText())\n if z == 't':\n spw.on_c0c1c2Button_clicked() # plot in pure component analysis space\n else:\n spw.on_c0c1tButton_clicked() # plot against time\n elif key == Qt.Key_W: # toggle plotting against RMSError, ignored in SpykeListViews\n z = str(spw.ui.zDimComboBox.currentText())\n if z == 'RMSerror':\n spw.on_c0c1c2Button_clicked() # plot in pure component analysis space\n else:\n spw.ui.zDimComboBox.setCurrentIndex(3)\n spw.on_plotButton_clicked() # plot against RMSError\n elif key in [Qt.Key_Enter, Qt.Key_Return]:\n # this is handled at a lower level by on_actionItem_triggered\n # in the various listview controls\n pass\n else:\n SpykeToolWindow.keyPressEvent(self, event) # pass it on\n\n def clear(self):\n \"\"\"Clear selections in this order: unsorted spikes, sorted spikes,\n cluster automatically selected for comparison, cluster 0, clusters\"\"\"\n spw = self.spykewindow\n clusters = spw.GetClusters()\n if len(self.uslist.selectedIndexes()) > 0:\n self.uslist.clearSelection()\n elif self.nslist.nrowsSelected > 0:\n self.nslist.clearSelection()\n elif len(clusters) == 2 and self._source in clusters:\n clusters.remove(self._source)\n spw.SelectClusters(clusters, on=False)\n elif 0 in spw.GetClusterIDs():\n for cluster in spw.GetClusters():\n if cluster.id == 0:\n spw.SelectClusters([cluster], on=False)\n break\n else:\n self.nlist.clearSelection()\n # reset colours in cluster plot:\n gw = spw.windows['Cluster'].glWidget\n gw.colour()\n gw.updateGL()\n\n def on_actionDelete_triggered(self):\n \"\"\"Delete explicity selected spikes, or clusters\"\"\"\n selsids = self.spykewindow.GetSpikes() # IDs of explicitly selected spikes\n nselsids = len(selsids)\n if (QApplication.instance().keyboardModifiers() & Qt.ControlModifier\n or nselsids > 0):\n self.delete_spikes()\n else:\n self.delete_clusters()\n\n def delete_clusters(self):\n \"\"\"Del button press/click\"\"\"\n spw = self.spykewindow\n clusters = spw.GetClusters()\n s = self.sort\n spikes = s.spikes\n sids = []\n for cluster in clusters:\n sids.append(cluster.neuron.sids)\n sids = np.concatenate(sids)\n\n # save some undo/redo stuff\n message = 'delete clusters %r' % [ c.id for c in clusters ]\n cc = ClusterChange(sids, spikes, message)\n cc.save_old(clusters, s.norder, s.good)\n\n # deselect and delete clusters\n spw.DelClusters(clusters)\n if len(s.clusters) > 0:\n # select cluster that replaces the first of the deleted clusters in norder\n selrows = [ cc.oldnorder.index(oldunid) for oldunid in cc.oldunids ]\n if len(selrows) > 0:\n selrow = selrows[0]\n nlist = spw.windows['Sort'].nlist\n nlist.selectRows(selrow) # TODO: this sets selection, but not focus\n #else: # first of deleted clusters was last in norder, don't select anything\n\n # save more undo/redo stuff\n newclusters = []\n cc.save_new(newclusters, s.norder, s.good)\n spw.AddClusterChangeToStack(cc)\n print(cc.message)\n\n def delete_spikes(self):\n \"\"\"CTRL+Del button press/click\"\"\"\n self.spykewindow.SplitSpikes(delete=True)\n\n def on_actionSplit_triggered(self):\n \"\"\"+ button click. Split off selected clusters into their own cluster\"\"\"\n self.spykewindow.SplitSpikes(delete=False)\n\n def on_actionMergeClusters_triggered(self):\n \"\"\"Merge button (M) click. Merge selected clusters. Easier to use than\n running gac() on selected clusters using a really big sigma to force\n them to all merge\"\"\"\n spw = self.spykewindow\n clusters = spw.GetClusters()\n s = self.sort\n spikes = s.spikes\n sids = [] # spikes to merge\n for cluster in clusters:\n sids.append(cluster.neuron.sids)\n # merge any selected usids as well\n sids.append(spw.GetUnsortedSpikes())\n sids = np.concatenate(sids)\n if len(sids) == 0:\n return\n\n # save some undo/redo stuff\n message = 'merge clusters %r' % [ c.id for c in clusters ]\n cc = ClusterChange(sids, spikes, message)\n cc.save_old(clusters, s.norder, s.good)\n\n # decide on newnid and where to insert it into norder\n newnid = None # merge by default into a new highest numbered nid\n inserti = None # order new cluster by default to end of nlist\n if len(clusters) == 1:\n # keep same position of this one nid in norder, regardless of whether it's\n # single-unit, multiunit, or junk\n inserti = s.norder.index(clusters[0].id)\n elif len(clusters) > 1:\n oldunids = np.asarray(cc.oldunids)\n suids = oldunids[oldunids > 0] # selected single unit nids\n if len(suids) > 0: # merge into largest selected single unit nid:\n spikecounts = np.asarray([ s.neurons[suid].nspikes for suid in suids ])\n newnid = suids[spikecounts.argmax()]\n inserti = s.norder.index(newnid)\n # correct for shift due to deletion of oldunids that precede newnid in norder:\n inserti -= sum([ s.norder.index(oldunid) < inserti for oldunid in oldunids])\n\n # delete selected clusters and deselect selected usids\n spw.DelClusters(clusters, update=False)\n self.uslist.clearSelection()\n\n # create new cluster\n #t0 = time.time()\n newcluster = spw.CreateCluster(update=False, id=newnid, inserti=inserti)\n neuron = newcluster.neuron\n self.MoveSpikes2Neuron(sids, neuron, update=False)\n plotdims = spw.GetClusterPlotDims()\n newcluster.update_pos()\n\n # save more undo/redo stuff\n cc.save_new([newcluster], s.norder, s.good)\n spw.AddClusterChangeToStack(cc)\n\n # now do some final updates\n spw.UpdateClustersGUI()\n spw.ColourPoints(newcluster)\n #print('applying clusters to plot took %.3f sec' % (time.time()-t0))\n # select newly created cluster\n spw.SelectClusters(newcluster)\n cc.message += ' into cluster %d' % newcluster.id\n print(cc.message)\n\n def on_actionToggleClustersGood_triggered(self):\n \"\"\"'Good' button (G) click. Toggle 'good' flag of all selected clusters\"\"\"\n spw = self.spykewindow\n clusters = spw.GetClusters()\n cids = []\n for cluster in clusters:\n cluster.neuron.good = not cluster.neuron.good\n cids.append(cluster.id)\n self.nlist.updateAll() # nlist item colouring will change as a result\n print(\"Toggled 'good' flag of clusters %r\" % cids)\n\n def on_actionLabelMultiunit_triggered(self):\n \"\"\"- button click. Label all selected clusters as multiunit by deleting them\n and creating new ones with -ve IDs\"\"\"\n spw = self.spykewindow\n clusters = spw.GetClusters()\n s = self.sort\n spikes = s.spikes\n # only relabel single unit clusters:\n clusters = [ cluster for cluster in clusters if cluster.id > 0 ]\n if len(clusters) == 0:\n return\n sids = []\n for cluster in clusters:\n sids.append(cluster.neuron.sids)\n sids = np.concatenate(sids)\n\n # save some undo/redo stuff\n message = 'label as multiunit clusters %r' % [ c.id for c in clusters ]\n cc = ClusterChange(sids, spikes, message)\n cc.save_old(clusters, s.norder, s.good)\n\n # delete old clusters\n inserti = s.norder.index(clusters[0].id)\n # collect cluster sids before cluster deletion\n sidss = [ cluster.neuron.sids for cluster in clusters ]\n spw.DelClusters(clusters, update=False)\n\n # create new multiunit clusters\n newclusters = []\n for sids in sidss:\n muid = s.get_nextmuid()\n newcluster = spw.CreateCluster(update=False, id=muid, inserti=inserti)\n neuron = newcluster.neuron\n self.MoveSpikes2Neuron(sids, neuron, update=False)\n newcluster.update_pos()\n newclusters.append(newcluster)\n inserti += 1\n\n # select newly labelled multiunit clusters\n spw.SelectClusters(newclusters)\n\n # save more undo/redo stuff\n cc.save_new(newclusters, s.norder, s.good)\n spw.AddClusterChangeToStack(cc)\n print(cc.message)\n\n def on_actionChanSplitClusters_triggered(self):\n \"\"\"Split by channels button (/) click\"\"\"\n ## TODO: make sure this works on .srf files! Why was chancombosplit being used?\n self.spykewindow.maxchansplit()\n #self.spykewindow.chancombosplit()\n\n def on_actionDensitySplit_triggered(self):\n \"\"\"Split cluster pair by density along line between their centers\"\"\"\n self.spykewindow.densitysplit()\n\n def on_actionRandomSplit_triggered(self):\n \"\"\"Randomly split each selected cluster in half\"\"\"\n self.spykewindow.randomsplit()\n\n def on_actionRenumber_triggered(self):\n if QApplication.instance().keyboardModifiers() & Qt.ControlModifier:\n self.renumber_selected_cluster()\n else:\n self.renumber_all_clusters()\n\n def renumber_selected_cluster(self):\n \"\"\"Renumber a single selected cluster to whatever free ID the user wants, for\n colouring purposes\"\"\"\n spw = self.spykewindow\n s = self.sort\n spikes = s.spikes\n\n cluster = spw.GetCluster() # exactly one selected cluster\n oldid = cluster.id\n newid = max(s.norder) + 1\n newid, ok = QtGui.QInputDialog.getInt(self, \"Renumber cluster\",\n \"This will clear the undo/redo stack, and is not undoable.\\n\"\n \"Enter new ID:\", value=newid)\n if not ok:\n return\n if newid in s.norder:\n print(\"Choose a non-existing nid to renumber to\")\n return\n # deselect cluster\n spw.SelectClusters(cluster, on=False)\n\n # rename to newid\n cluster.id = newid # this indirectly updates neuron.id\n # update cluster and neuron dicts, and spikes array\n s.clusters[newid] = cluster\n s.neurons[newid] = cluster.neuron\n sids = cluster.neuron.sids\n spikes['nid'][sids] = newid\n # remove duplicate oldid dict entries\n del s.clusters[oldid]\n del s.neurons[oldid]\n # replace oldid with newid in norder\n s.norder[s.norder.index(oldid)] = newid\n # update colour of any relevant points in cluster plot\n spw.ColourPoints(cluster)\n # reselect cluster\n spw.SelectClusters(cluster)\n # some cluster changes in stack may no longer be applicable, reset cchanges\n del spw.cchanges[:]\n spw.cci = -1\n print('Renumbered neuron %d to %d' % (oldid, newid))\n\n def renumber_all_clusters(self):\n \"\"\"Renumber single unit clusters consecutively from 1, ordered by y position. Do the\n same for multiunit (-ve number) clusters, starting from -1. Sorting by y position\n makes user inspection of clusters more orderly, makes the presence of duplicate\n clusters more obvious, and allows for maximal spatial separation between clusters of\n the same colour, reducing colour conflicts\"\"\"\n val = QtGui.QMessageBox.question(self.panel, \"Renumber all clusters\",\n \"Are you sure? This will clear the undo/redo stack, and is not undoable.\",\n QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)\n if val == QtGui.QMessageBox.No:\n return\n\n spw = self.spykewindow\n s = self.sort\n spikes = s.spikes\n\n # get spatially and numerically ordered lists of new ids\n oldids = np.asarray(s.norder)\n oldsuids = oldids[oldids > 0]\n oldmuids = oldids[oldids < 0]\n # this is a bit confusing: find indices that would sort old ids by y pos, but then\n # what you really want is to find the y pos *rank* of each old id, so you need to\n # take argsort again:\n newsuids = np.asarray([ s.clusters[cid].pos['y0']\n for cid in oldsuids ]).argsort().argsort() + 1\n newmuids = np.asarray([ s.clusters[cid].pos['y0']\n for cid in oldmuids ]).argsort().argsort() + 1\n newmuids = -newmuids\n # multiunit, followed by single unit, no 0 junk cluster. Can't seem to do it the other\n # way around as of Qt 4.7.2 - it seems QListViews don't like having a -ve value in\n # the last entry. Doing so causes all 2 digit values in the list to become blank,\n # suggests a spacing calculation bug. Reproduce by making last entry multiunit,\n # undoing then redoing. Actually, maybe the bug is it doesn't like having a number\n # in the last entry with fewer digits than the preceding entry. Only seems to be a\n # problem when setting self.setUniformItemSizes(True).\n newids = np.concatenate([newmuids, newsuids])\n\n # test\n if np.all(oldids == newids):\n print('Nothing to renumber: cluster IDs already ordered in y0 and contiguous')\n return\n # update for replacing oldids with newids\n oldids = np.concatenate([oldmuids, oldsuids])\n\n # deselect current selections\n selclusters = spw.GetClusters()\n oldselids = [ cluster.id for cluster in selclusters ]\n spw.SelectClusters(selclusters, on=False)\n\n # delete junk cluster, if it exists\n if 0 in s.clusters:\n s.remove_neuron(0)\n print('Deleted junk cluster 0')\n if 0 in oldselids:\n oldselids.remove(0)\n\n # replace old ids with new ids\n cw = spw.windows['Cluster']\n oldclusters = s.clusters.copy() # no need to deepcopy, just copy refs, not clusters\n dims = spw.GetClusterPlotDims()\n for oldid, newid in zip(oldids, newids):\n newid = int(newid) # keep as Python int, not numpy int\n if oldid == newid:\n continue # no need to waste time removing and recreating this cluster\n # change all occurences of oldid to newid\n cluster = oldclusters[oldid]\n cluster.id = newid # this indirectly updates neuron.id\n # update cluster and neuron dicts\n s.clusters[newid] = cluster\n s.neurons[newid] = cluster.neuron\n sids = cluster.neuron.sids\n spikes['nid'][sids] = newid\n\n # remove any orphaned cluster ids\n for oldid in oldids:\n if oldid not in newids:\n del s.clusters[oldid]\n del s.neurons[oldid]\n\n # reset norder\n s.norder = []\n s.norder.extend(sorted([ int(newid) for newid in newmuids ])[::-1])\n s.norder.extend(sorted([ int(newid) for newid in newsuids ]))\n\n # now do some final updates\n spw.UpdateClustersGUI()\n spw.ColourPoints(s.clusters.values())\n # reselect the previously selected (but now renumbered) clusters,\n # helps user keep track\n oldiis = [ list(oldids).index(oldselid) for oldselid in oldselids ]\n newselids = newids[oldiis]\n spw.SelectClusters([s.clusters[cid] for cid in newselids])\n # all cluster changes in stack are no longer applicable, reset cchanges\n del spw.cchanges[:]\n spw.cci = -1\n print('Renumbering complete')\n\n def on_actionFind_triggered(self):\n \"\"\"Find current cluster or spike\"\"\"\n ctrl = QApplication.instance().keyboardModifiers() & Qt.ControlModifier\n if ctrl:\n self.FindSpike()\n else:\n self.FindCluster()\n\n def FindCluster(self):\n \"\"\"Move focus to location of currently selected (single) cluster\"\"\"\n spw = self.spykewindow\n try:\n cluster = spw.GetCluster()\n except RuntimeError as err:\n print(err)\n return\n gw = spw.windows['Cluster'].glWidget\n dims = spw.GetClusterPlotDims()\n gw.focus = np.float32([ cluster.normpos[dim] for dim in dims ])\n gw.panTo() # pan to new focus\n gw.updateGL()\n\n def FindSpike(self):\n \"\"\"Move focus to location of currently selected (single) spike\"\"\"\n spw = self.spykewindow\n try:\n sid = spw.GetSpike()\n except RuntimeError as err:\n print(err)\n return\n gw = spw.windows['Cluster'].glWidget\n pointis = gw.sids.searchsorted(sid)\n gw.focus = gw.points[pointis]\n gw.panTo() # pan to new focus\n gw.updateGL()\n\n def on_actionSelectRandomSpikes_triggered(self):\n \"\"\"Select random sample of spikes in current cluster(s), or random sample\n of unsorted spikes if no cluster(S) selected\"\"\"\n nsamples = int(self.nsamplesComboBox.currentText())\n if len(self.nslist.neurons) > 0:\n slist = self.nslist\n else:\n slist = self.uslist\n slist.clearSelection() # emits selectionChanged signal, .reset() doesn't\n slist.selectRandom(nsamples)\n\n def on_gainComboBox_triggered(self):\n \"\"\"Set gain of panel based on gainComboBox selection\"\"\"\n panel = self.panel\n panel.gain = float(self.gainComboBox.currentText())\n panel.do_layout() # resets axes lims and recalcs panel.pos\n panel._update_scale()\n panel.draw_refs()\n panel.updateAllItems()\n\n def on_actionAlignMin_triggered(self):\n self.Align('min')\n\n def on_actionAlignMax_triggered(self):\n self.Align('max')\n\n def on_actionAlignBest_triggered(self):\n self.Align('best')\n\n def on_actionShiftLeft_triggered(self):\n if QApplication.instance().keyboardModifiers() & Qt.ControlModifier:\n nt = -1\n else:\n nt = -2\n self.Shift(nt)\n \n def on_actionShiftRight_triggered(self): \n if QApplication.instance().keyboardModifiers() & Qt.ControlModifier:\n nt = 1\n else:\n nt = 2\n self.Shift(nt)\n\n def on_incltComboBox_triggered(self):\n \"\"\"Change length of chan selection lines, optionally trigger cluster replot\"\"\"\n self.panel.update_selvrefs()\n self.panel.draw_refs()\n #self.spykewindow.ui.plotButton.click()\n\n def get_inclt(self):\n \"\"\"Return inclt value in incltComboBox\"\"\"\n return float(self.incltComboBox.currentText()) # us\n\n inclt = property(get_inclt)\n\n def get_tis(self):\n \"\"\"Return tis (start and end timepoint indices) of duration inclt, asymmetric around\n t=0 spike time. Note that any changes to the code here should also be made in the\n timepoint selection display code in SortPanel.update_selvrefs()\"\"\"\n s = self.sort\n inclt = self.inclt # duration to include, asymmetric around t=0 spike time (us)\n tw = self.panel.tw\n dtw = tw[1] - tw[0] # spike time window width\n left = intround(abs(tw[0]) / dtw * inclt) # left fraction wrt t=0 spike time\n right = inclt - left # right fraction wrt t=0 spike time\n tis = s.twts.searchsorted([-left, right])\n return tis\n\n tis = property(get_tis)\n\n def on_nPCsPerChanSpinBox_valueChanged(self, val):\n self.sort.npcsperchan = val\n\n def on_actionReloadSpikes_triggered(self):\n spw = self.spykewindow\n sids = spw.GetAllSpikes()\n sort = self.sort\n if len(sids) == 0:\n # if no spikes specified, reload all spikes\n sids = sort.spikes['id']\n usemeanchans = False\n if QApplication.instance().keyboardModifiers() & Qt.ControlModifier:\n usemeanchans = True\n sort.reload_spikes_and_templates(sids, usemeanchans=usemeanchans)\n # add sids to the set of dirtysids to be resaved to .wave file:\n spw.update_dirtysids(sids)\n # auto-refresh all plots:\n self.panel.updateAllItems()\n\n def on_actionFindPrevMostSimilar_triggered(self):\n self.findMostSimilarCluster('previous')\n\n def on_actionFindNextMostSimilar_triggered(self):\n self.findMostSimilarCluster('next')\n\n def on_actionToggleErrors_toggled(self, checked):\n self.panel.showFills(checked)\n\n def on_slider_valueChanged(self, slideri):\n self.nslist.clearSelection() # emits selectionChanged signal, .reset() doesn't\n if self.nslist.model().sliding == False:\n self.nslist.model().sids.sort() # change from nid order to sid order\n self.nslist.updateAll() # update to reflect new ordering\n self.nslist.model().sliding = True\n nsamples = int(self.nsamplesComboBox.currentText())\n rows = np.arange(slideri, slideri+nsamples)\n self.nslist.selectRows(rows)\n\n def on_slider_sliderPressed(self):\n \"\"\"Make slider click (without movement) highlight the first nsamples\n or fewer spikes when slider is at 0 position\"\"\"\n slideri = self.slider.value()\n if slideri == 0:\n nsamples = int(self.nsamplesComboBox.currentText())\n nsamples = min(nsamples, self.nslist.model().nspikes)\n rows = np.arange(nsamples)\n self.nslist.selectRows(rows)\n\n def update_slider(self):\n \"\"\"Update slider limits and step sizes\"\"\"\n nsamples = int(self.nsamplesComboBox.currentText())\n nsids = len(self.nslist.sids)\n ulim = max(nsids-nsamples, 1) # upper limit\n self.slider.setRange(0, ulim)\n self.slider.setSingleStep(1)\n self.slider.setPageStep(nsamples)\n\n def findMostSimilarCluster(self, which='next'):\n \"\"\"If no chans selected, compare source to next or previous most similar cluster\n based on chans the two have in common, while requiring the two have each others'\n max chans in common. If chans have been selected, use them as a starting set of\n chans to compare on. Also, use only the timepoint range selected in incltComboBox\"\"\"\n try:\n source = self.getClusterComparisonSource()\n except RuntimeError as err:\n print(err)\n return\n destinations = list(self.sort.clusters.values())\n destinations.remove(source)\n selchans = np.sort(self.panel.chans_selected)\n if len(selchans) > 0:\n srcchans = np.intersect1d(source.neuron.wave.chans, selchans)\n if len(srcchans) == 0:\n print(\"Source cluster doesn't overlap with selected chans\")\n return\n else:\n srcchans = source.neuron.wave.chans\n\n if self.spykewindow.ui.normButton.isChecked():\n print(\"NOTE: findMostSimilarCluster() doesn't currently take spike amplitude \"\n \"normalization into account. To see the true amplitudes used to compare \"\n \"neuron pairs, turn off normalization\")\n\n errors = []\n dests = []\n t0i, t1i = self.tis # timepoint range selected in incltComboBox\n # try and compare source neuron waveform to all destination neuron waveforms\n for dest in destinations:\n if dest.neuron.wave.data is None: # hasn't been calculated yet\n dest.neuron.update_wave()\n dstchans = dest.neuron.wave.chans\n if len(selchans) > 0:\n if not set(selchans).issubset(dstchans):\n continue\n dstchans = selchans\n cmpchans = np.intersect1d(srcchans, dstchans)\n if len(cmpchans) == 0: # not comparable\n continue\n # ensure maxchan of both source and dest neuron are both in cmpchans\n if source.neuron.chan not in cmpchans or dest.neuron.chan not in cmpchans:\n continue\n srcwavedata = source.neuron.wave[cmpchans].data[:, t0i:t1i]\n dstwavedata = dest.neuron.wave[cmpchans].data[:, t0i:t1i]\n error = core.rms(srcwavedata - dstwavedata)\n errors.append(error)\n dests.append(dest)\n if len(errors) == 0:\n print(\"No sufficiently overlapping clusters on selected chans to compare to\")\n return\n errors = np.asarray(errors)\n dests = np.asarray(dests)\n desterrsortis = errors.argsort()\n\n if which == 'next':\n self._cmpid += 1\n elif which == 'previous':\n self._cmpid -= 1\n else: raise ValueError('Unknown which: %r' % which)\n self._cmpid = max(self._cmpid, 0)\n self._cmpid = min(self._cmpid, len(dests)-1)\n\n dest = dests[desterrsortis][self._cmpid]\n self.spykewindow.SelectClusters(dest)\n desterr = errors[desterrsortis][self._cmpid]\n print('n%d to n%d rmserror: %.2f uV' %\n (source.id, dest.id, self.sort.converter.AD2uV(desterr)))\n\n def getClusterComparisonSource(self):\n selclusters = self.spykewindow.GetClusters()\n errmsg = 'unclear which cluster to use as source for comparison'\n if len(selclusters) == 1:\n source = selclusters[0]\n self._source = source\n self._cmpid = -1 # init/reset\n elif len(selclusters) == 2:\n source = self._source\n if source not in selclusters:\n raise RuntimeError(errmsg)\n # deselect old destination cluster:\n selclusters.remove(source)\n self.spykewindow.SelectClusters(selclusters, on=False)\n else:\n self._source = None # reset for tidiness\n raise RuntimeError(errmsg)\n return source\n\n def Shift(self, nt):\n \"\"\"Shift selected sids by nt timepoints\"\"\"\n s = self.sort\n spikes = s.spikes\n spw = self.spykewindow\n sids = np.concatenate((spw.GetClusterSpikes(), spw.GetUnsortedSpikes()))\n self.sort.shift(sids, nt)\n print('Shifted %d spikes by %d timepoints' % (len(sids), nt))\n unids = np.unique(spikes['nid'][sids])\n neurons = [ s.neurons[nid] for nid in unids ]\n for neuron in neurons:\n neuron.update_wave() # update affected mean waveforms\n # add dirtysids to the set to be resaved to .wave file:\n spw.update_dirtysids(sids)\n # auto-refresh all plots\n self.panel.updateAllItems()\n\n def Align(self, to):\n \"\"\"Align all implicitly selected spikes to min or max, or best fit\n on selected chans\"\"\" \n s = self.sort\n spikes = s.spikes\n spw = self.spykewindow\n sids = np.concatenate((spw.GetClusterSpikes(), spw.GetUnsortedSpikes()))\n if to == 'best':\n tis = self.tis\n # find which chans are common to all sids:\n commonchans = s.get_common_chans(sids)[0]\n # check selected chans\n selchans = spw.get_selchans(sids)\n for selchan in selchans:\n if selchan not in commonchans:\n print(\"Chan %d not common to all spikes, pick from %r\"\n % (selchan, list(commonchans)))\n return\n print('Best fit aligning %d spikes between tis=%r on chans=%r' %\n (len(sids), list(tis), selchans))\n # numpy implementation:\n #dirtysids = s.alignbest(sids, tis, selchans)\n # cython implementation:\n dirtysids = util.alignbest_cy(s, sids, tis, np.int64(selchans))\n else: # to in ['min', 'max']\n print('Aligning %d spikes to %s' % (len(sids), to))\n dirtysids = s.alignminmax(sids, to)\n paligned = len(dirtysids) / len(sids) * 100\n print('Aligned %d/%d (%.1f%%) spikes' % (len(dirtysids), len(sids), paligned))\n unids = np.unique(spikes['nid'][dirtysids])\n neurons = [ s.neurons[nid] for nid in unids ]\n for neuron in neurons:\n neuron.update_wave() # update affected mean waveforms\n # add dirtysids to the set to be resaved to .wave file:\n spw.update_dirtysids(dirtysids)\n # auto-refresh all plots:\n self.panel.updateAllItems()\n\n def RemoveNeuron(self, neuron, update=True):\n \"\"\"Remove neuron and all its spikes from the GUI and the Sort\"\"\"\n self.MoveSpikes2List(neuron, neuron.sids, update=update)\n self.sort.remove_neuron(neuron.id)\n if update:\n self.nlist.updateAll()\n\n def MoveSpikes2Neuron(self, sids, neuron=None, update=True):\n \"\"\"Assign spikes from sort.spikes to a neuron, and trigger eventual update of\n mean wave. If neuron is None, create a new one\"\"\"\n sids = toiter(sids)\n spikes = self.sort.spikes\n if neuron == None:\n neuron = self.sort.create_neuron()\n neuron.sids = np.union1d(neuron.sids, sids) # update\n spikes['nid'][sids] = neuron.id\n if update:\n self.sort.update_usids()\n self.uslist.updateAll()\n if neuron in self.nslist.neurons:\n self.nslist.neurons = self.nslist.neurons # trigger nslist refresh\n # TODO: selection doesn't seem to be working, always jumps to top of list\n #self.uslist.Select(row) # automatically select the new item at that position\n neuron.wave.data = None # trigger template mean update\n return neuron\n\n def MoveSpikes2List(self, neuron, sids, update=True):\n \"\"\"Move spikes from a neuron back to the unsorted spike list control\"\"\"\n sids = toiter(sids)\n if len(sids) == 0:\n return # nothing to do\n spikes = self.sort.spikes\n neuron.sids = np.setdiff1d(neuron.sids, sids) # return what's in 1st arr and not in 2nd\n spikes['nid'][sids] = 0 # unbind neuron id of sids in spikes struct array\n if update:\n self.sort.update_usids()\n self.uslist.updateAll()\n # this only makes sense if the neuron is currently selected in the nlist:\n if neuron in self.nslist.neurons:\n self.nslist.neurons = self.nslist.neurons # this triggers a refresh\n neuron.wave.data = None # triggers an update when it's actually needed\n\n def PlotClusterHistogram(self, X, nids):\n \"\"\"Plot histogram of given clusters along a single dimension. If two clusters are\n given, project them onto axis connecting their centers, and calculate separation\n indices between them. Otherwise, plot the distribution of all given clusters\n (up to a limit) along the first dimension in X.\"\"\"\n spw = self.spykewindow\n mplw = spw.OpenWindow('MPL')\n unids = np.unique(nids) # each unid corresponds to a cluster, except possibly unid 0\n nclusters = len(unids)\n if nclusters == 0:\n mplw.ax.clear()\n mplw.figurecanvas.draw()\n print(\"No spikes selected\")\n return\n elif nclusters > 5: # to prevent slowdowns, don't plot too many\n mplw.ax.clear()\n mplw.figurecanvas.draw()\n print(\"Too many clusters selected for cluster histogram\")\n return\n elif nclusters == 2:\n calc_measures = True\n else:\n calc_measures = False\n projdimi = 0\n\n ndims = X.shape[1]\n points = [] # list of projection of each cluster's points onto dimi\n for unid in unids:\n sidis, = np.where(nids == unid)\n # don't seem to need contig points for NDsepmetric, no need for copy:\n points.append(X[sidis])\n #points.append(np.ascontiguousarray(X[sidis]))\n if calc_measures:\n t0 = time.time()\n NDsep = util.NDsepmetric(*points, Nmax=20000)\n print('NDsep calc took %.3f sec' % (time.time()-t0))\n # centers of both clusters, use median:\n c0 = np.median(points[0], axis=0) # ndims vector\n c1 = np.median(points[1], axis=0)\n # line connecting the centers of the two clusters, wrt c0\n line = c1-c0\n line /= np.linalg.norm(line) # make it unit length\n #print('c0=%r, c1=%r, line=%r' % (c0, c1, line))\n else:\n line = np.zeros(ndims)\n line[projdimi] = 1.0 # pick out just the one component\n c0 = 0.0 # set origin at 0\n # calculate projection of each cluster's points onto line\n projs = []\n for cpoints in points:\n projs.append(np.dot(cpoints-c0, line))\n if calc_measures:\n d = np.median(projs[1]) - np.median(projs[0])\n # measure whether centers are at least 3 of the bigger stdevs away from\n # each other:\n maxstd = max(projs[0].std(), projs[1].std())\n if maxstd == 0:\n oneDsep = 0 # not sure if this is ideal\n else:\n oneDsep = d / (3 * maxstd)\n #print('std0=%f, std1=%f, d=%f' % (projs[0].std(), projs[1].std(), d))\n proj = np.concatenate(projs)\n nbins = max(intround(np.sqrt(len(proj))), 2) # seems like a good heuristic\n #print('nbins = %d' % nbins)\n edges = np.histogram(proj, bins=nbins)[1]\n hists = []\n for i in range(nclusters):\n hists.append(np.histogram(projs[i], bins=edges)[0])\n hist = np.concatenate([hists]) # one cluster hist per row\n masses = np.asarray([ h.sum() for h in hist ])\n sortedmassis = masses.argsort()\n # Take the fraction of area that the two distribs overlap.\n # At each bin, take min value of the two distribs. Add up all those min values,\n # and divide by the mass of the smaller distrib.\n if calc_measures:\n overlaparearatio = hist.min(axis=0).sum() / masses[sortedmassis[0]]\n djs = core.DJS(hists[0], hists[1])\n # plotting:\n ledges = edges[:-1] # keep just the left edges, discard the last right edge\n assert len(ledges) == nbins\n binwidth = ledges[1] - ledges[0]\n # plot:\n a = mplw.ax\n a.clear()\n windowtitle = \"clusters %r\" % list(unids)\n print(windowtitle)\n mplw.setWindowTitle(windowtitle)\n if calc_measures:\n #title = (\"sep index=%.3f, overlap area ratio=%.3f, DJS=%.3f, sqrt(DJS)=%.3f\"\n # % (oneDsep, overlaparearatio, djs, np.sqrt(djs)))\n title = (\"%dDsep=%.3f, 1Dsep=%.3f, OAR=%.3f, DJS=%.3f\"\n % (ndims, NDsep, oneDsep, overlaparearatio, djs))\n print(title)\n a.set_title(title)\n cs = [ CLUSTERCOLOURDICT[unid] for unid in unids ]\n for i, c in enumerate(cs):\n # due to white background, replace white clusters with black:\n if c == WHITE:\n cs[i] = 'black'\n # plot the smaller cluster last, to maximize visibility:\n for i in sortedmassis[::-1]:\n a.bar(ledges, hist[i], width=binwidth, color=cs[i], edgecolor=cs[i])\n ## TODO: tight_layout call needs updating for MPL 2.2:\n #mplw.f.tight_layout(pad=0.3) # crop figure to contents\n mplw.figurecanvas.draw()\n",
"\"\"\"Core classes and functions used throughout spyke\"\"\"\n\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import with_statement\n\n__authors__ = ['Martin Spacek', 'Reza Lotun']\n\nimport sys\nimport os\nimport hashlib\nimport time\nimport datetime\nfrom collections import OrderedDict as odict\n\nimport random\nimport string\nfrom copy import copy\nimport json\nimport pickle\n\nfrom PyQt4 import QtCore, QtGui\nfrom PyQt4.QtCore import Qt\ngetSaveFileName = QtGui.QFileDialog.getSaveFileName\n\nimport numpy as np\nfrom numpy import pi, cos, sin\nimport scipy.signal, scipy.io\n\nimport matplotlib as mpl\n\n# set some numpy print and error options - these hold for all modules in spyke:\nnp.set_printoptions(linewidth=100,\n formatter={'float_kind':'{:f}'.format}) # disable scientific notation\n#np.set_printoptions(precision=6, floatmode='maxprec')\n#np.set_printoptions(precision=3, threshold=1000, edgeitems=5, linewidth=150, suppress=True)\n# make overflow, div by zero, and invalid raise errors, and underflow just raise a warning,\n# so that program doesn't halt on underflow during gaussian fit in extract module:\nnp.seterr(over='raise', divide='raise', invalid='raise', under='warn')\n\nUNIXEPOCH = datetime.datetime(1970, 1, 1, 0, 0, 0) # UNIX epoch: Jan 1, 1970\n\nNULL = b'\\x00'\n\n# For .dat and .nsx files, only allow start and stop time requests that deviate up to\n# DATSAMPLEERRPCT from the nearest (re)sample timepoint. This avoids roundoff errors for\n# time requests that fall exactly in between (50%) (re)sample timepoints:\nDATSAMPLEERRPCT = 49.9 # percent\n\nDEFDATFILTMETH = 'BW' # default .dat filter method: None, 'BW', 'WMLDR'\nDEFNSXFILTMETH = 'BW' # default .nsx filter method: None, 'BW', 'WMLDR'\nBWHPF0 = 300 # Butterworth high-pass filter low-frequency cutoff, Hz\nBWLPF1 = 300 # Butterworth low-pass filter high-frequency cutoff, Hz\nBWHPORDER = 4 # Butterworth high-pass filter order\nBWLPORDER = 4 # Butterworth low-pass filter order\n# low-pass filter raw data to get low-pass stream?\n# otherwise just decimate, which is simpler and faster, but aliases:\nLOWPASSFILTERLPSTREAM = True\n\nDEFCAR = 'Median' # default common average reference method: None, 'Median', 'Mean';\n # 'Median' works best because it's least affected by spikes\n\nDEFHPRESAMPLEX = 2 # default highpass resampling factor for all stream types\nDEFLPSAMPLFREQ = 1000 # default lowpass sampling rate for wide-band stream types, Hz\nDEFHPDATSHCORRECT = False ## TODO: this may not hold for open-ephys and Intan chips!\nDEFHPNSXSHCORRECT = False # no need for .nsx files, s+h delay is only 1 ns between chans\nDEFHPSRFSHCORRECT = True\n\nSRFNCHANSPERBOARD = 32 # used for s+h delay correction in .srf files\n\n# Apparently KERNELSIZE == number of kernel zero crossings, but that seems to depend on\n# the phase of the kernel, some have one less, depending on the channel (when doing sample\n# and hold correction). Anyway, total number of points in the kernel is KERNELSIZE plus 1\n# (for the middle point) - see Blanche2006.\n# Should kernel size depend on the sampling rate? No, but perhaps the minimum kernel\n# size depends on the Nyquist rate.\nKERNELSIZE = 12\n# kernel size needs to be even, otherwise there's a slight but undesireable time shift,\n# perhaps because sampfreq always needs to be an integer multiple of rawsampfreq:\nassert KERNELSIZE % 2 == 0\n# number of excess raw datapoints to include on either side of each wideband Stream\n# (such as a DATStream or NSXStream) during a slice call. Due to the lack of analog filtering,\n# a greater excess is needed than e.g. SurfStream because it's already analog filtered\nXSWIDEBANDPOINTS = 200\n\nMAXLONGLONG = 2**63-1\nMAXNBYTESTOFILE = 2**31 # max array size safe to call .tofile() on in Numpy 1.5.0 on Windows\n\nMAXNSPIKEPLOTS = 50\nMAXNROWSLISTSELECTION = 10000\n\nCHANFIELDLEN = 256 # channel string field length at start of .resample file\n\nINVPI = 1 / pi\n\n\nclass EmptyClass(object):\n pass\n\n\nclass Converter(object):\n \"\"\"Store intgain and extgain values and provide methods to convert between AD and uV\n values for .srf files, even when a Stream (where intgain and extgain are stored) isn't\n available\"\"\"\n def __init__(self, intgain, extgain):\n self.intgain = intgain\n self.extgain = extgain\n\n def AD2uV(self, AD):\n \"\"\"Convert rescaled AD values to float32 uV\n Biggest +ve voltage is 10 million uV, biggest +ve rescaled signed int16 AD val\n is half of 16 bits, then divide by internal and external gains\n\n TODO: unsure: does the DT3010 acquire from -10 to 10 V at intgain == 1 and encode\n that from 0 to 4095?\n \"\"\"\n return np.float32(AD) * 10000000 / (2**15 * self.intgain * self.extgain)\n\n def uV2AD(self, uV, dtype=np.int16):\n \"\"\"Convert uV to signed rescaled AD values of type dtype\"\"\"\n return dtype(np.round(uV * (2**15 * self.intgain * self.extgain) / 10000000))\n\n\nclass Converter_TSF_1002(object):\n \"\"\"Store intgain and extgain values and provide methods to convert between AD and uV\n values, even when a Stream (where intgain and extgain are stored) isn't available. Meant\n specifically for .tsf version 1002 files, which have no specific AD voltage limits, and\n already come as signed values centered around 0 V\"\"\"\n def __init__(self, intgain, extgain):\n self.intgain = intgain # uV per AD value\n self.extgain = extgain\n\n def AD2uV(self, AD):\n \"\"\"Convert signed int16 AD values to float32 uV\"\"\"\n return np.float32(AD) * self.intgain * self.extgain\n\n def uV2AD(self, uV, dtype=np.int16):\n \"\"\"Convert float32 uV to signed AD values of type dtype\"\"\"\n return dtype(np.round(uV / (self.intgain * self.extgain)))\n\n\nclass SimpleConverter(object):\n \"\"\"Store conversion factors between AD values and uV values, and provide\n methods to convert between them, even when a stream isn't available. Note that\n conceptually, AD2uVx is identical to uVperAD\"\"\"\n def __init__(self, AD2uVx):\n self.AD2uVx = AD2uVx\n self.uV2ADx = 1 / AD2uVx\n\n def AD2uV(self, AD):\n return self.AD2uVx * np.float32(AD)\n \n def uV2AD(self, uV, dtype=np.int16):\n return dtype(np.round(self.uV2ADx * uV))\n\n\nclass DatConverter(SimpleConverter):\n pass\n\n\nclass NSXConverter(SimpleConverter):\n pass\n\n\nclass WaveForm(object):\n \"\"\"Just a container for data, std of data, timestamps, channels, and saturation indices.\n Sliceable in time, and indexable in channel space. Only really used for\n convenient plotting. Everything else uses the sort.wavedata array, and\n related sort.spikes fields\"\"\"\n def __init__(self, data=None, std=None, ts=None, chans=None, tres=None, satis=None):\n self.data = data # in AD, potentially multichannel, depending on shape\n self.std = std # standard deviation, same shape as data\n self.ts = ts # timestamps array in us, one for each sample (column) in data\n self.chans = chans # channel ids corresponding to rows in .data\n self.tres = tres # timestamp resolution, in us\n self.satis = satis # boolean array denoting saturation, same shape as data\n\n def __getitem__(self, key):\n \"\"\"Make waveform data sliceable in time, and directly indexable by channel id(s).\n Return a new WaveForm\"\"\"\n \n # check for std field, won't exist for old saved Waveforms in .sort files:\n try: self.std\n except AttributeError: self.std = None\n \n if type(key) == slice: # slice self in time\n if self.ts is None:\n return WaveForm() # empty WaveForm\n # use timestamp indices instead of timestamps, to avoid searchsorted\n # problems with potential float roundoff errors:\n try:\n self.tis\n except AttributeError:\n self.tis = intround(self.ts / self.tres) # calc timestamp indices on first use\n t0i, t1i = intround(key.start / self.tres), intround(key.stop / self.tres)\n lo, hi = self.tis.searchsorted([t0i, t1i])\n # direct method can cause occasional float roundoff error if self.ts are float:\n #lo, hi = self.ts.searchsorted([key.start, key.stop])\n data = self.data[:, lo:hi]\n if self.std is None:\n std = None\n else:\n std = self.std[:, lo:hi]\n ts = self.ts[lo:hi]\n # return a new WaveForm:\n return WaveForm(data=data, std=std, ts=ts, chans=self.chans, tres=self.tres)\n else: # index into self by channel id(s)\n keys = toiter(key)\n # don't assume self.chans are sorted:\n try:\n chanis = argmatch(self.chans, keys)\n except ValueError:\n raise IndexError('Invalid index %r' % key)\n data = self.data[chanis] # grab the appropriate rows of data\n if self.std is None:\n std = None\n else:\n std = self.std[chanis]\n # return a new WaveForm:\n return WaveForm(data=data, std=std, ts=self.ts, chans=keys, tres=self.tres)\n\n def __getstate__(self):\n \"\"\"Don't pickle self.tis, it can always be regenerated\"\"\"\n d = self.__dict__.copy() # copy it cuz we'll be making changes\n try: del d['tis']\n except KeyError: pass\n return d\n\n def __len__(self):\n \"\"\"Number of data points in time\"\"\"\n nt = len(self.ts)\n assert nt == self.data.shape[1] # obsessive\n return nt\n\n def _check_add_sub(self, other):\n \"\"\"Check a few things before adding or subtracting waveforms\"\"\"\n if self.data.shape != other.data.shape:\n raise ValueError(\"Waveform shapes %r and %r don't match\" %\n (self.data.shape, other.data.shape))\n if self.chans != other.chans:\n raise ValueError(\"Waveform channel ids %r and %r don't match\" %\n (self.chans, other.chans))\n\n def __add__(self, other):\n \"\"\"Return new waveform which is self+other. Keep self's timestamps\"\"\"\n self._check_add_sub(other)\n return WaveForm(data=self.data+other.data,\n ts=self.ts, chans=self.chans, tres=self.tres)\n\n def __sub__(self, other):\n \"\"\"Return new waveform which is self-other. Keep self's timestamps\"\"\"\n self._check_add_sub(other)\n return WaveForm(data=self.data-other.data,\n ts=self.ts, chans=self.chans, tres=self.tres)\n\n \nclass SpykeToolWindow(QtGui.QMainWindow):\n \"\"\"Base class for all of spyke's tool windows\"\"\"\n def __init__(self, parent, flags=Qt.Tool):\n QtGui.QMainWindow.__init__(self, parent, flags)\n self.maximized = False\n\n def keyPressEvent(self, event):\n key = event.key()\n modifiers = event.modifiers()\n shift = modifiers == Qt.ShiftModifier # only modifier is shift\n if key == Qt.Key_F11:\n self.toggleMaximized()\n elif key == Qt.Key_S and shift:\n self.on_actionSave_triggered()\n else:\n QtGui.QMainWindow.keyPressEvent(self, event) # pass it on\n\n def mouseDoubleClickEvent(self, event):\n \"\"\"Doesn't catch window titlebar doubleclicks for some reason (window manager\n catches them?). Have to doubleclick on a part of the window with no widgets in it\"\"\"\n self.toggleMaximized()\n\n def closeEvent(self, event):\n # remove 'Window' from class name\n windowtype = type(self).__name__.replace('Window', '')\n self.parent().HideWindow(windowtype)\n\n def toggleMaximized(self):\n if not self.maximized:\n self.normalPos, self.normalSize = self.pos(), self.size()\n dw = QtGui.QDesktopWidget()\n rect = dw.availableGeometry(self)\n self.setGeometry(rect)\n self.maximized = True\n else: # restore\n self.resize(self.normalSize)\n self.move(self.normalPos)\n self.maximized = False\n\n def on_actionSave_triggered(self):\n \"\"\"Save panel to file\"\"\"\n f = self.panel.figure\n\n # copied and adapted from mpl.backend_qt4.NavigationToolbar2QT.save_figure():\n filetypes = f.canvas.get_supported_filetypes_grouped()\n sorted_filetypes = filetypes.items()\n sorted_filetypes.sort()\n default_filetype = f.canvas.get_default_filetype()\n\n startpath = mpl.rcParams.get('savefig.directory', '')\n startpath = os.path.expanduser(startpath)\n start = os.path.join(startpath, f.canvas.get_default_filename())\n filters = []\n selectedFilter = None\n for name, exts in sorted_filetypes:\n exts_list = \" \".join(['*.%s' % ext for ext in exts])\n filter = '%s (%s)' % (name, exts_list)\n if default_filetype in exts:\n selectedFilter = filter\n filters.append(filter)\n filters = ';;'.join(filters)\n fname = getSaveFileName(self.panel, \"Save panel to\",\n start, filters, selectedFilter)\n if fname:\n fname = str(fname) # convert from QString\n if startpath == '':\n # explicitly missing key or empty str signals to use cwd\n mpl.rcParams['savefig.directory'] = startpath\n else:\n # save dir for next time\n mpl.rcParams['savefig.directory'] = os.path.dirname(str(fname))\n try:\n f.canvas.print_figure(fname, facecolor=None, edgecolor=None)\n except Exception as e:\n QtGui.QMessageBox.critical(\n self.panel, \"Error saving file\", str(e),\n QtGui.QMessageBox.Ok, QtGui.QMessageBox.NoButton)\n print('Panel saved to %r' % fname)\n\n\nclass SpykeListView(QtGui.QListView):\n def __init__(self, parent):\n QtGui.QListView.__init__(self, parent)\n self.sortwin = parent\n #self.setSelectionBehavior(QTableWidget.SelectRows)\n self.setSelectionMode(QtGui.QListView.ExtendedSelection)\n self.setLayoutMode(QtGui.QListView.Batched) # prevents lockup during huge layout ops\n # Setting resize mode to \"adjust\" sometimes results in a bug where Qt seems to\n # be reflowing the contents many times over before it finally stops, resulting in\n # very slow operations when changing list contents (like adding/removing neurons).\n # But, with this disabled, the contents no longer reflow, and you're forced to use\n # scrollbars unnecessarily to see all the list contents. This might also be\n # interacting with the setWrapping and/or setBatchSize features:\n #self.setResizeMode(QtGui.QListView.Adjust) # recalculates layout on resize\n self.setUniformItemSizes(True) # speeds up listview\n self.setFlow(QtGui.QListView.LeftToRight) # default is TopToBottom\n self.setWrapping(True)\n self.setBatchSize(300)\n #self.setViewMode(QtGui.QListView.IconMode)\n\n def mousePressEvent(self, event):\n sw = self.sortwin\n buttons = event.buttons()\n if buttons == QtCore.Qt.LeftButton:\n QtGui.QListView.mousePressEvent(self, event) # handle as usual\n else:\n self.sortwin.mousePressEvent(event) # pass on up to Sort window\n\n def keyPressEvent(self, event):\n key = event.key()\n modifiers = event.modifiers()\n ctrldown = bool(modifiers & Qt.ControlModifier)\n ctrlup = not ctrldown\n if (key in [Qt.Key_A, Qt.Key_X, Qt.Key_N, Qt.Key_M, Qt.Key_G,\n Qt.Key_Equal, Qt.Key_Minus, Qt.Key_Slash,\n Qt.Key_P, Qt.Key_Backslash, Qt.Key_NumberSign, Qt.Key_F, Qt.Key_R,\n Qt.Key_E, Qt.Key_B, Qt.Key_BracketLeft, Qt.Key_BracketRight,\n Qt.Key_Comma, Qt.Key_Period, Qt.Key_F5, Qt.Key_C, Qt.Key_T, Qt.Key_W]\n or ctrlup and key == Qt.Key_Space):\n event.ignore() # pass it on up to the parent\n else:\n QtGui.QListView.keyPressEvent(self, event) # handle it as usual\n\n def selectionChanged(self, selected, deselected, prefix=None):\n \"\"\"Plot neurons or spikes on list item selection\"\"\"\n # For short lists, display the actual selection in the list, otherwise, if there are\n # too many entries in the list, selection gets unbearably slow, especially as you\n # select items further down the list. So for very long lists, don't actually show the\n # selection. The selection events all still seem to work though, and for some reason\n # sometimes the selections themselves are displayed, even when selected\n # programmatically:\n if self.nrows < MAXNROWSLISTSELECTION:\n QtGui.QListView.selectionChanged(self, selected, deselected)\n panel = self.sortwin.panel\n addis = [ qvar2int(i.data()) for i in selected.indexes() ]\n remis = [ qvar2int(i.data()) for i in deselected.indexes() ]\n panel.removeItems([ prefix+str(i) for i in remis ])\n # for speed, don't allow more than MAXNSPIKEPLOTS spikes to be plotted in sort panel:\n if prefix == 's':\n '''\n # note that self.nrowsSelected seems to report nrows selected *including* those\n # added and removed by the current selection event\n net = len(addis) - len(remis)\n print('nselected: %d' % self.nrowsSelected)\n print('Net change: %d' % net)\n nwereselected = self.nrowsSelected - net\n print('num were selected is %d' % nwereselected)\n maxnadd = max(MAXNSPIKEPLOTS - nwereselected + len(remis), 0)\n print('maxnadd is %d' % maxnadd)\n addis = addis[:maxnadd]\n '''\n nadd = len(addis)\n maxnadd = max(MAXNSPIKEPLOTS - self.nrowsSelected + nadd, 0)\n if maxnadd == 0:\n return\n if nadd > maxnadd:\n # if we can't add all the requested spikes to the sort panel without\n # exceeding MAXNSPIKEPLOTS, then randomly sample however many we can still\n # add (maxnadd), and add them to the sort panel\n #print('Adding %d randomly sampled plots of %d selected spikes'\n # % (maxnadd, self.nrowsSelected))\n addis = random.sample(addis, maxnadd)\n #t0 = time.time()\n panel.addItems([ prefix+str(i) for i in addis ])\n #print('addItems took %.3f sec' % (time.time()-t0))\n #print(\"Done selchanged, %r, addis=%r, remis=%r\" % (prefix, addis, remis))\n\n def updateAll(self):\n self.model().updateAll()\n\n def get_nrows(self):\n return self.model().rowCount()\n\n nrows = property(get_nrows)\n\n def selectRows(self, rows, on=True):\n \"\"\"Row selection in listview is complex. This makes it simpler\"\"\"\n ## TODO: There's a bug here, where if you select the last two neurons in nlist,\n ## (perhaps these last two need to be near a list edge), merge them, and then\n ## undo, then merge again (instead of just redoing), then undo again, they're\n ## both selected, but only the first is replotted because the selchanged event\n ## is only passed the first of the two as being newly selected. If however\n ## before remerging, you clear the selection or select something else, and then\n ## go back and select those same two neurons and merge, and undo, it works fine,\n ## and the selchanged event gets both items as newly selected. Seems like a Qt\n ## bug, or at least some very subtle timing problem of some kind. This might have\n ## something to do with reflow when changing list contents, but even resetting\n ## listview behaviour to default doesn't make this go away. Also, seems to happen\n ## for selection of one index at a time, and for doing it all in one go with a\n ## QItemSelection.\n \n rows = toiter(rows)\n m = self.model()\n sm = self.selectionModel()\n if on:\n flag = sm.Select\n else:\n flag = sm.Deselect\n #print('start select=%r loop for rows %r' % (on, rows))\n '''\n # unnecessarily emits nrows selectionChanged signals, causes slow\n # plotting in mpl commit 50fc548465b1525255bc2d9f66a6c7c95fd38a75 (pre\n # 1.0) and later:\n [ sm.select(m.index(row), flag) for row in rows ]\n '''\n # emits single selectionChanged signal, more efficient, but causes a bit of\n # flickering, or at least used to in Qt 4.7.0:\n sel = QtGui.QItemSelection()\n for row in rows:\n index = m.index(row)\n #print('row: %r, index: %r' % (row, index))\n sel.select(index, index) # topleft to bottomright\n #print('sel has indexes, rows, cols, data:')\n #for index in sel.indexes():\n # print(index, index.row(), index.column(), index.data())\n sm.select(sel, flag)\n #print('end select loop')\n '''\n # constantly scrolling to selection slows everything quite noticeably, especially\n # when using the spike selection sortwin.slider\n if scrollTo and on and len(rows) > 0: # scroll to last row that was just selected\n self.scrollTo(m.index(rows[-1]))\n '''\n def selectedRows(self):\n \"\"\"Return list of selected rows\"\"\"\n return [ i.row() for i in self.selectedIndexes() ]\n\n def rowSelected(self, row):\n \"\"\"Simple way to check if a row is selected\"\"\"\n return self.model().index(row) in self.selectedIndexes()\n\n def get_nrowsSelected(self):\n return len(self.selectedIndexes())\n\n nrowsSelected = property(get_nrowsSelected)\n\n def selectRandom(self, start, stop, nsamples):\n \"\"\"Select random sample of rows\"\"\"\n start = max(0, start)\n if stop == -1:\n stop = self.nrows\n stop = min(self.nrows, stop)\n nrows = stop - start\n nsamples = min(nsamples, nrows)\n rows = random.sample(range(start, stop), nsamples)\n self.selectRows(rows)\n\n\nclass NList(SpykeListView):\n \"\"\"Neuron list view\"\"\"\n def __init__(self, parent):\n SpykeListView.__init__(self, parent)\n self.setModel(NListModel(parent))\n self.setItemDelegate(NListDelegate(parent))\n #self.connect(self, QtCore.SIGNAL(\"activated(QModelIndex)\"),\n # self.on_actionItem_triggered)\n # alternate style of connecting signals, seems \"activated\" is needed now with\n # new style signals and slots, instead of \"triggered\", even though \"activated\"\n # is supposed to be deprecated:\n self.activated.connect(self.on_actionItem_triggered)\n\n def selectionChanged(self, selected, deselected):\n SpykeListView.selectionChanged(self, selected, deselected, prefix='n')\n selnids = [ qvar2int(i.data()) for i in self.selectedIndexes() ]\n #if 1 <= len(selnids) <= 3: # populate nslist if exactly 1, 2 or 3 neurons selected\n self.sortwin.nslist.neurons = [ self.sortwin.sort.neurons[nid] for nid in selnids ]\n #else:\n # self.sortwin.nslist.neurons = []\n\n def on_actionItem_triggered(self, index):\n sw = self.sortwin\n sw.parent().ui.plotButton.click()\n\n\nclass NSList(SpykeListView):\n \"\"\"Neuron-Spike list view. Displays spikes of currently selected neuron(s).\n For high performance when quickly selecting large numbers of points via 'painting'\n in the cluster window, a 'fake' selection is maintained separately from the actual\n selection in the list view\"\"\"\n def __init__(self, parent):\n SpykeListView.__init__(self, parent)\n self.setModel(NSListModel(parent))\n #self.connect(self, QtCore.SIGNAL(\"activated(QModelIndex)\"),\n # self.on_actionItem_triggered)\n self.activated.connect(self.on_actionItem_triggered)\n self.clear_fake_selection()\n\n def selectRows(self, rows, on=True):\n \"\"\"Normal (manual) row selection\"\"\"\n self.clear_fake_selection()\n SpykeListView.selectRows(self, rows, on=on)\n\n def fake_selectRows(self, rows, on=True, plot=True):\n \"\"\"Fake row selection, same interface as normal selectRows()\"\"\"\n panel = self.sortwin.panel\n SpykeListView.clearSelection(self) # clear any manually selected rows\n if on: # fake select\n self.fake_selected_rows = np.union1d(self.fake_selected_rows, rows)\n if plot:\n # add at most MAXNSPIKEPLOTS to sort panel:\n nfreeplots = MAXNSPIKEPLOTS - len(panel.used_plots)\n if nfreeplots < len(rows):\n panel.removeAllSpikes()\n nfreeplots = MAXNSPIKEPLOTS\n plot_sids = self.sids[rows[:nfreeplots]]\n panel.addItems([ 's'+str(sid) for sid in plot_sids ])\n else: # fake deselect\n self.fake_selected_rows = np.setxor1d(self.fake_selected_rows, rows)\n # Remove at most all currently plotted spikes in sort panel.\n # Not all fake selected spikes are necessarily plotted, and therefore\n # deselecting fake selected spikes in cluster window won't necessarily\n # have corresponding spikes to remove from the sort panel:\n panel.removeItems([ 's'+str(i) for i in self.sids[rows] ])\n #panel.removeAllSpikes() # more drastic, but less interactive\n\n def selectedRows(self):\n \"\"\"Return selected rows\"\"\"\n real = np.int64([ i.row() for i in self.selectedIndexes() ])\n fake = self.fake_selected_rows\n return np.concatenate([real, fake])\n\n def rowSelected(self, row):\n \"\"\"Simple way to check if a row is selected\"\"\"\n return (self.model().index(row) in self.selectedIndexes() or\n row in self.fake_selected_rows)\n\n def get_nrowsSelected(self):\n return len(self.selectedIndexes()) + len(self.fake_selected_rows)\n\n nrowsSelected = property(get_nrowsSelected)\n\n def clearSelection(self):\n SpykeListView.clearSelection(self)\n self.clear_fake_selection()\n self.sortwin.panel.removeAllSpikes()\n\n def clear_fake_selection(self):\n self.fake_selected_rows = np.array([], dtype=int)\n\n def selectionChanged(self, selected, deselected):\n SpykeListView.selectionChanged(self, selected, deselected, prefix='s')\n\n def on_actionItem_triggered(self, index):\n sw = self.sortwin\n if sw.sort.stream.is_open():\n sid = self.sids[index.row()]\n spike = sw.sort.spikes[sid]\n sw.parent().seek(spike['t'])\n else:\n sw.parent().ui.plotButton.click()\n\n def get_neurons(self):\n return self.model().neurons\n\n def set_neurons(self, neurons):\n \"\"\"Every time neurons are set, clear any existing selection and update data model\"\"\"\n self.clearSelection() # remove any plotted sids, at least for now\n self.model().neurons = neurons\n\n neurons = property(get_neurons, set_neurons)\n\n def get_nids(self):\n return np.asarray([ neuron.id for neuron in self.model().neurons ])\n\n nids = property(get_nids)\n\n def get_sids(self):\n return self.model().sids\n\n sids = property(get_sids)\n\n def keyPressEvent(self, event):\n sw = self.sortwin\n key = event.key()\n # passing horizontal keys to nlist assumes nslist is a single column\n # and are therefore not needed:\n if key in [Qt.Key_Enter, Qt.Key_Return]:\n sw.nlist.keyPressEvent(event) # pass on to nlist\n else:\n SpykeListView.keyPressEvent(self, event) # handle it as usual\n\n def selectRandom(self, nsamples):\n \"\"\"Select up to nsamples random rows per neuron\"\"\"\n if self.model().sliding == True:\n self.neurons = self.neurons # trigger NSListModel.set_neurons() call\n self.model().sliding = False\n for neuron in self.neurons:\n allrows = self.sids.searchsorted(neuron.sids)\n nsamples = min(nsamples, len(allrows))\n rows = np.random.choice(allrows, nsamples, replace=False)\n self.selectRows(rows)\n\n\nclass USList(SpykeListView):\n \"\"\"Unsorted spike list view\"\"\"\n def __init__(self, parent):\n SpykeListView.__init__(self, parent)\n self.setModel(USListModel(parent))\n #self.connect(self, QtCore.SIGNAL(\"activated(QModelIndex)\"),\n # self.on_actionItem_triggered)\n self.activated.connect(self.on_actionItem_triggered)\n\n def keyPressEvent(self, event):\n sw = self.sortwin\n key = event.key()\n if key in [Qt.Key_Enter, Qt.Key_Return]:\n sw.nlist.keyPressEvent(event) # pass on to nlist\n else:\n SpykeListView.keyPressEvent(self, event) # handle it as usual\n\n def selectionChanged(self, selected, deselected):\n SpykeListView.selectionChanged(self, selected, deselected, prefix='s')\n\n def on_actionItem_triggered(self, index):\n sw = self.sortwin\n if sw.sort.stream.is_open():\n sid = sw.sort.usids[index.row()]\n spike = sw.sort.spikes[sid]\n sw.parent().seek(spike['t'])\n else:\n sw.parent().ui.plotButton.click()\n\n def selectRandom(self, nsamples):\n \"\"\"Select up to nsamples random rows\"\"\"\n SpykeListView.selectRandom(self, 0, -1, nsamples)\n\n\nclass SpykeAbstractListModel(QtCore.QAbstractListModel):\n def __init__(self, parent):\n QtCore.QAbstractListModel.__init__(self, parent)\n self.sortwin = parent\n\n def updateAll(self):\n \"\"\"Emit dataChanged signal so that view updates itself immediately.\n Hard to believe this doesn't already exist in some form\"\"\"\n i0 = self.createIndex(0, 0) # row, col\n i1 = self.createIndex(self.rowCount()-1, 0) # seems this isn't necessary\n # seems to refresh all, though should only refresh 1st row:\n #self.dataChanged.emit(i0, i0)\n self.dataChanged.emit(i0, i1) # refresh all\n\n\nclass NListModel(SpykeAbstractListModel):\n \"\"\"Model for neuron list view\"\"\"\n def rowCount(self, parent=None):\n try:\n # update nlist tooltip before returning, only +ve nids count as neurons:\n sort = self.sortwin.sort\n neurons = sort.neurons\n nneurons = (np.asarray(sort.norder) > 0).sum()\n goodnids = sort.get_good()\n ngood = len(goodnids)\n ngoodspikes = sum(neurons[nid].nspikes for nid in goodnids)\n self.sortwin.nlist.setToolTip(\"Neuron list\\n\"\n \"%d neurons\\n\"\n \"%d good with %d spikes\"\n % (nneurons, ngood, ngoodspikes))\n return len(sort.norder)\n except AttributeError: # sort doesn't exist\n self.sortwin.nlist.setToolTip(\"Neuron list\")\n return 0\n\n def data(self, index, role=Qt.DisplayRole):\n if index.isValid():\n neurons = self.sortwin.sort.neurons\n norder = self.sortwin.sort.norder\n try:\n nid = norder[index.row()]\n except IndexError:\n print('WARNING: tried to index non-existent row %d' % index.row())\n #print('.data(): row=%d, val=%d' % (index.row(), nid))\n if role == Qt.DisplayRole:\n return nid # no need to use QVariant() apparently\n elif role == Qt.ToolTipRole:\n neuron = neurons[nid]\n try:\n chan = neuron.chan\n except ValueError: # probably not enough overlapping chans for a template\n chan = None\n pos = neuron.cluster.pos\n return ('nid: %d\\n' % nid +\n '%d spikes\\n' % neuron.nspikes +\n 'chan: %r\\n' % chan +\n 't: %d us\\n' % pos['t'] +\n 'dt: %.4g us\\n' % pos['dt'] +\n 'x0: %.4g um\\n' % pos['x0'] +\n 'y0: %.4g um\\n' % pos['y0'] +\n 'Vpp: %.4g uV\\n' % pos['Vpp'] +\n 'sx: %.4g um' % pos['sx'])\n # this stuff is handled in NListDelegate:\n '''\n elif role == Qt.ForegroundRole:\n if nid in self.sortwin.sort.get_good():\n return QtGui.QBrush(QtGui.QColor(255, 255, 255))\n elif role == Qt.BackgroundRole:\n if nid in self.sortwin.sort.get_good():\n return QtGui.QBrush(QtGui.QColor(0, 128, 0))\n '''\nclass SListModel(SpykeAbstractListModel):\n \"\"\"Base model for spike list models\"\"\"\n def spiketooltip(self, spike):\n return ('sid: %d\\n' % spike['id'] +\n 'nid: %d\\n' % spike['nid'] +\n 'chan: %d\\n' % spike['chan'] +\n 't: %d us\\n' % spike['t'] +\n 'dt: %.4g us\\n' % spike['dt'] +\n 'x0: %.4g um\\n' % spike['x0'] +\n 'y0: %.4g um\\n' % spike['y0'] +\n 'Vpp: %.4g uV\\n' % spike['Vpp'] +\n 'sx: %.4g um' % spike['sx'])\n\n\nclass NSListModel(SListModel):\n \"\"\"Model for neuron spikes list view\"\"\"\n def __init__(self, parent):\n SpykeAbstractListModel.__init__(self, parent)\n self._neurons = []\n self.nspikes = 0\n self.sids = np.empty(0, dtype=np.int32)\n\n def get_neurons(self):\n return self._neurons\n\n def set_neurons(self, neurons):\n self._neurons = neurons\n if neurons:\n self.sids = np.concatenate([ neuron.sids for neuron in neurons ])\n self.sids.sort() # keep them sorted\n self.sortwin.slider.setEnabled(True)\n else:\n self.sids = np.empty(0, dtype=np.int32)\n self.sortwin.slider.setEnabled(False)\n self.nspikes = len(self.sids)\n # triggers new calls to rowCount() and data(), and critically, clears selection\n # before moving slider to pos 0, which triggers slider.valueChanged:\n self.reset()\n self.sortwin.slider.setValue(0) # reset position to 0\n self.sortwin.update_slider() # update limits and step sizes\n self.sliding = False\n\n neurons = property(get_neurons, set_neurons)\n\n def rowCount(self, parent=None):\n # update nslist tooltip before returning:\n self.sortwin.nslist.setToolTip(\"Sorted spike list\\n%d spikes\" % self.nspikes)\n return self.nspikes\n\n def data(self, index, role=Qt.DisplayRole):\n if index.isValid() and role in [Qt.DisplayRole, Qt.ToolTipRole]:\n sid = int(self.sids[index.row()])\n if role == Qt.DisplayRole:\n return sid\n elif role == Qt.ToolTipRole:\n spike = self.sortwin.sort.spikes[sid]\n return self.spiketooltip(spike)\n\n\nclass USListModel(SListModel):\n \"\"\"Model for unsorted spike list view\"\"\"\n def rowCount(self, parent=None):\n try:\n nspikes = len(self.sortwin.sort.usids)\n # update uslist tooltip before returning:\n self.sortwin.uslist.setToolTip(\"Unsorted spike list\\n%d spikes\" % nspikes)\n return nspikes\n except AttributeError: # sort doesn't exist\n self.sortwin.uslist.setToolTip(\"Unsorted spike list\")\n return 0\n\n def data(self, index, role=Qt.DisplayRole):\n if index.isValid() and role in [Qt.DisplayRole, Qt.ToolTipRole]:\n sid = int(self.sortwin.sort.usids[index.row()])\n if role == Qt.DisplayRole:\n return sid\n elif role == Qt.ToolTipRole:\n spike = self.sortwin.sort.spikes[sid]\n return self.spiketooltip(spike)\n\n\nclass NListDelegate(QtGui.QStyledItemDelegate):\n \"\"\"Delegate for neuron list view, modifies appearance of items\"\"\"\n def __init__(self, parent):\n QtGui.QStyledItemDelegate.__init__(self, parent)\n self.sortwin = parent\n palette = QtGui.QApplication.palette()\n self.selectedgoodbrush = QtGui.QBrush(QtGui.QColor(0, 0, 255)) # blue\n self.unselectedgoodbrush = QtGui.QBrush(QtGui.QColor(0, 128, 0)) # mid green\n self.selectedbrush = palette.highlight()\n self.unselectedbrush = palette.base()\n self.selectedgoodpen = QtGui.QPen(Qt.white)\n self.unselectedgoodpen = QtGui.QPen(Qt.white)\n self.selectedpen = QtGui.QPen(palette.highlightedText().color())\n self.unselectedpen = QtGui.QPen(palette.text().color())\n self.focusedpen = QtGui.QPen(Qt.gray, 0, Qt.DashLine)\n self.focusedpen.setDashPattern([1, 1])\n self.focusedpen.setCapStyle(Qt.FlatCap)\n\n def paint(self, painter, option, index):\n \"\"\"Change background colour for nids designated as \"good\"\"\"\n model = index.model()\n nid = model.data(index) # should come out as an int\n good = nid in self.sortwin.sort.get_good()\n # don't care whether self is active or inactive, only care about\n # selection, \"good\", and focused states\n selected = option.state & QtGui.QStyle.State_Selected\n focused = option.state & QtGui.QStyle.State_HasFocus\n painter.save()\n # paint background:\n painter.setPen(QtGui.QPen(Qt.NoPen))\n if selected:\n if good:\n painter.setBrush(self.selectedgoodbrush)\n else: # use default selection brush\n painter.setBrush(self.selectedbrush)\n else: # unselected\n if good:\n painter.setBrush(self.unselectedgoodbrush)\n else: # use default background brush\n painter.setBrush(self.unselectedbrush)\n painter.drawRect(option.rect)\n # paint focus rect:\n if focused:\n rect = copy(option.rect)\n painter.setBrush(Qt.NoBrush) # no need to draw bg again\n painter.setPen(self.focusedpen)\n rect.adjust(0, 0, -1, -1) # make space for outline\n painter.drawRect(rect)\n # paint foreground:\n value = index.data(Qt.DisplayRole)\n if selected:\n if good:\n painter.setPen(self.selectedgoodpen)\n else: # use default selection pen\n painter.setPen(self.selectedpen)\n else: # unselected\n if good:\n painter.setPen(self.unselectedgoodpen)\n else: # use default background pen\n painter.setPen(self.unselectedpen)\n text = qvar2str(value)\n painter.drawText(option.rect, Qt.AlignCenter, text)\n painter.restore()\n\n\nclass ClusterTabSpinBox(QtGui.QSpinBox):\n \"\"\"Intercept CTRL+Z key event for cluster undo instead of spinbox edit undo\"\"\"\n def keyPressEvent(self, event):\n if event.key() == Qt.Key_Z and event.modifiers() == Qt.ControlModifier:\n self.topLevelWidget().on_actionUndo_triggered()\n else:\n QtGui.QSpinBox.keyPressEvent(self, event) # handle it as usual\n\n\nclass ClusterTabDoubleSpinBox(QtGui.QDoubleSpinBox):\n \"\"\"Intercept CTRL+Z key event for cluster undo instead of spinbox edit undo\"\"\"\n def keyPressEvent(self, event):\n if event.key() == Qt.Key_Z and event.modifiers() == Qt.ControlModifier:\n self.topLevelWidget().on_actionUndo_triggered()\n else:\n QtGui.QDoubleSpinBox.keyPressEvent(self, event) # handle it as usual\n\n\nclass ClusteringGroupBox(QtGui.QGroupBox):\n \"\"\"Make ENTER key event activate the cluster button\"\"\"\n def keyPressEvent(self, event):\n if event.key() in [Qt.Key_Enter, Qt.Key_Return]:\n self.topLevelWidget().ui.clusterButton.click()\n else:\n QtGui.QGroupBox.keyPressEvent(self, event) # handle it as usual\n\n\nclass PlottingGroupBox(QtGui.QGroupBox):\n \"\"\"Make ENTER key event activate the plot button\"\"\"\n def keyPressEvent(self, event):\n if event.key() in [Qt.Key_Enter, Qt.Key_Return]:\n self.topLevelWidget().ui.plotButton.click()\n else:\n QtGui.QGroupBox.keyPressEvent(self, event) # handle it as usual\n\n\nclass XCorrsGroupBox(QtGui.QGroupBox):\n \"\"\"Make ENTER key event activate the correlograms plot button\"\"\"\n def keyPressEvent(self, event):\n if event.key() in [Qt.Key_Enter, Qt.Key_Return]:\n self.topLevelWidget().ui.plotXcorrsButton.click()\n else:\n QtGui.QGroupBox.keyPressEvent(self, event) # handle it as usual\n\n\nclass SpikeSelectionSlider(QtGui.QSlider):\n \"\"\"Make ENTER key event activate the plot button\"\"\"\n def keyPressEvent(self, event):\n if event.key() in [Qt.Key_Enter, Qt.Key_Return]:\n self.topLevelWidget().spykewindow.ui.plotButton.click()\n else:\n QtGui.QSlider.keyPressEvent(self, event) # handle it as usual\n\n\nclass Stack(list):\n \"\"\"A list that doesn't allow -ve indices\"\"\"\n def __getitem__(self, key):\n if key < 0:\n raise IndexError('Stack index %d out of range' % key)\n return list.__getitem__(self, key)\n\n\nclass ClusterChange(object):\n \"\"\"Stores info for undoing/redoing a change to any set of clusters\"\"\"\n def __init__(self, sids, spikes, message):\n self.sids = sids\n self.spikes = spikes\n self.message = message\n\n def __repr__(self):\n return self.message\n\n def save_old(self, oldclusters, oldnorder, oldgood):\n self.oldnids = self.spikes['nid'][self.sids] # this seems to create a copy\n self.oldunids = [ c.id for c in oldclusters ]\n self.oldposs = [ c.pos.copy() for c in oldclusters ]\n self.oldnormposs = [ c.normpos.copy() for c in oldclusters ]\n self.oldnorder = copy(oldnorder)\n self.oldgood = copy(oldgood)\n\n def save_new(self, newclusters, newnorder, newgood):\n self.newnids = self.spikes['nid'][self.sids] # this seems to create a copy\n self.newunids = [ c.id for c in newclusters ]\n self.newposs = [ c.pos.copy() for c in newclusters ]\n self.newnormposs = [ c.normpos.copy() for c in newclusters ]\n self.newnorder = copy(newnorder)\n self.newgood = copy(newgood)\n\n\ndef get_sha1(fname, blocksize=2**20):\n \"\"\"Gets the sha1 hash of file designated by fname (with full path)\"\"\"\n m = hashlib.sha1()\n with open(fname, 'rb') as f:\n # continually update hash until EOF\n while True:\n block = f.read(blocksize)\n if not block:\n break\n m.update(block)\n return m.hexdigest()\n\ndef intround(n):\n \"\"\"Round to the nearest integer, return an integer. Works on arrays.\n Saves on parentheses, nothing more\"\"\"\n if iterable(n): # it's a sequence, return as an int64 array\n return np.int64(np.round(n))\n else: # it's a scalar, return as normal Python int\n return int(round(n))\n\ndef intfloor(n):\n \"\"\"Round down to the nearest integer, return an integer. Works on arrays.\n Saves on parentheses, nothing more\"\"\"\n if iterable(n): # it's a sequence, return as an int64 array\n return np.int64(np.floor(n))\n else: # it's a scalar, return as normal Python int\n return int(np.floor(n))\n\ndef intceil(n):\n \"\"\"Round up to the nearest integer, return an integer. Works on arrays.\n Saves on parentheses, nothing more\"\"\"\n if iterable(n): # it's a sequence, return as an int64 array\n return np.int64(np.ceil(n))\n else: # it's a scalar, return as normal Python int\n return int(np.ceil(n))\n\ndef iterable(x):\n \"\"\"Check if the input is iterable, stolen from numpy.iterable()\"\"\"\n try:\n iter(x)\n return True\n except TypeError:\n return False\n\ndef toiter(x):\n \"\"\"Convert to iterable. If input is iterable, returns it. Otherwise returns it in a list.\n Useful when you want to iterate over something (like in a for loop),\n and you don't want to have to do type checking or handle exceptions\n when it isn't a sequence\"\"\"\n if iterable(x):\n return x\n else:\n return [x]\n\ndef tolist(x):\n \"\"\"Convert to list if not already a list\"\"\"\n try:\n return list(x)\n except TypeError: # x is not iterable\n return [x]\n\ndef tocontig(x):\n \"\"\"Return C contiguous copy of array x if it isn't C contiguous already\"\"\"\n if not x.flags.c_contiguous:\n x = x.copy()\n return x\n'''\n# use np.vstack instead:\ndef cvec(x):\n \"\"\"Return x as a column vector. x must be a scalar or a vector\"\"\"\n x = np.asarray(x)\n assert x.squeeze().ndim in [0, 1]\n try:\n nrows = len(x)\n except TypeError: # x is scalar?\n nrows = 1\n x.shape = (nrows, 1)\n return x\n'''\ndef is_empty(x):\n \"\"\"Check if sequence is empty. There really should be a np.is_empty function\"\"\"\n print(\"WARNING: not thoroughly tested!!!\")\n x = np.asarray(x)\n if np.prod(x.shape) == 0:\n return True\n else:\n return False\n\ndef cut(ts, trange):\n \"\"\"Returns timestamps, where tstart <= timestamps <= tend\n Copied and modified from neuropy rev 149\"\"\"\n lo, hi = argcut(ts, trange)\n return ts[lo:hi] # slice it\n\ndef argcut(ts, trange):\n \"\"\"Returns timestamp slice indices, where tstart <= timestamps <= tend\n Copied and modified from neuropy rev 149\"\"\"\n tstart, tend = trange[0], trange[1]\n '''\n # this is what we're trying to do:\n return ts[ (ts >= tstart) & (ts <= tend) ]\n ts.searchsorted([tstart, tend]) method does it faster, because it assumes ts are ordered.\n It returns an index where the values would fit in ts. The index is such that\n ts[index-1] < value <= ts[index]. In this formula ts[ts.size]=inf and ts[-1]= -inf\n '''\n lo, hi = ts.searchsorted([tstart, tend]) # indices where tstart and tend would fit in ts\n # can probably avoid all this end inclusion code by using the 'side' kwarg,\n # not sure if I want end inclusion anyway:\n '''\n if tend == ts[min(hi, len(ts)-1)]:\n # if tend matches a timestamp (protect from going out of index bounds when checking)\n hi += 1 # inc to include a timestamp if it happens to exactly equal tend.\n # This gives us end inclusion\n hi = min(hi, len(ts)) # limit hi to max slice index (==max value index + 1)\n '''\n return lo, hi\n\ndef argmatch(a, v):\n \"\"\"\n Find indices into `a` where elements in `v` match those in `a`.\n\n Find the indices into an array `a` whose values match those queried in `v`.\n Both arrays are first flattened to 1D, and the values in `a` must be unique.\n This is an accelerated equivalent of:\n\n `np.array([ int(np.where(a == val)[0]) for val in v ])`\n\n Parameters\n ----------\n a : 1-D array_like\n Input array.\n v : array_like\n Values to match against `a`.\n\n Returns\n -------\n indices : array of ints\n Array of indices into `a` with the same shape as `v`.\n\n Adapted from http://stackoverflow.com/a/8251668\n See numpy GH PR: https://github.com/numpy/numpy/pull/9055\n \"\"\"\n a, v = np.ravel(a), np.ravel(v)\n if len(a) != len(np.unique(a)):\n raise ValueError(\"Values in `a` must be unique for unambiguous results\")\n if not np.in1d(v, a).all():\n raise ValueError(\"Values array %s is not a subset of input array %s\" % (v, a))\n asortis = a.argsort()\n return asortis[a.searchsorted(v, sorter=asortis)]\n\ndef dist(a, b):\n \"\"\"Return the Euclidean distance between two N-dimensional coordinates\"\"\"\n a = np.asarray(a)\n b = np.asarray(b)\n return np.sqrt(((a-b)**2).sum())\n\ndef eucd(coords):\n \"\"\"Generates Euclidean distance matrix from a\n sequence of n m-dimensional coordinates. Nice and fast.\n Written by Willi Richert\n Taken from:\n http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498246\n on 2006/11/11\n \"\"\"\n coords = np.array(coords)\n n, m = coords.shape\n delta = np.zeros((n, n), dtype=np.float64)\n for d in range(m):\n data = coords[:, d]\n delta += (data - data[:, np.newaxis]) ** 2\n return np.sqrt(delta)\n\ndef revcmp(x, y):\n \"\"\"Does the reverse of cmp():\n Return negative if y<x, zero if y==x, positive if y>x\"\"\"\n return cmp(y, x)\n\n\nclass Gaussian(object):\n \"\"\"Gaussian function, works with ndarray inputs\"\"\"\n def __init__(self, mu, sigma):\n self.mu = mu\n self.sigma = sigma\n\n def __call__(self, x):\n \"\"\"Called when self is called as a f'n.\n Don't bother normalizing by 1/(sigma*np.sqrt(2*pi)),\n don't care about normalizing the integral,\n just want to make sure that f(0) == 1\"\"\"\n return np.exp( -(x-self.mu)**2 / (2*self.sigma**2) )\n\n def __getitem__(self, x):\n \"\"\"Called when self is indexed into\"\"\"\n return self(x)\n\n\ndef g(x0, sx, x):\n \"\"\"1-D Gaussian\"\"\"\n return np.exp( -(x-x0)**2 / (2*sx**2) )\n\ndef g2(x0, y0, sx, sy, x, y):\n \"\"\"2-D Gaussian\"\"\"\n arg = -(x-x0)**2 / (2*sx**2) - (y-y0)**2 / (2*sy**2)\n return np.exp(arg)\n\ndef g2s(x0, y0, s, x, y):\n \"\"\"Symmetric 2-D Gaussian\"\"\"\n arg = -(x-x0)**2 / (2*s**2) - (y-y0)**2 / (2*s**2)\n return np.exp(arg)\n\ndef g3(x0, y0, z0, sx, sy, sz, x, y, z):\n \"\"\"3-D Gaussian\"\"\"\n return np.exp( -(x-x0)**2 / (2*sx**2) - (y-y0)**2 / (2*sy**2) - (z-z0)**2 / (2*sz**2) )\n\ndef cauchy(x0, gx, x):\n \"\"\"1-D Cauchy. See http://en.wikipedia.org/wiki/Cauchy_distribution\"\"\"\n #return INVPI * gx/((x-x0)**2+gx**2)\n gx2 = gx * gx\n return gx2 / ((x-x0)**2 + gx2)\n\ndef cauchy2(x0, y0, gx, gy, x, y):\n \"\"\"2-D Cauchy\"\"\"\n #return INVPI * gx/((x-x0)**2+gx**2) * gy/((y-y0)**2+gy**2)\n return (gx*gy)**2 / ((x-x0)**2 + gx**2) / ((y-y0)**2 + gy**2)\n\ndef Vf(Im, x0, y0, z0, sx, sy, sz, x, y, z):\n \"\"\"1/r voltage decay function in 2D space\n What to do with the singularity so that the leastsq gets a smooth differentiable f'n?\"\"\"\n #if np.any(x == x0) and np.any(y == y0) and np.any(z == z0):\n # raise ValueError, 'V undefined at singularity'\n return Im / (4*pi) / np.sqrt( sx**2 * (x-x0)**2 + sy**2 * (y-y0)**2 + sz**2 * (z-z0)**2)\n\ndef dgdmu(mu, sigma, x):\n \"\"\"Partial of g wrt mu\"\"\"\n return (x - mu) / sigma**2 * g(mu, sigma, x)\n\ndef dgdsigma(mu, sigma, x):\n \"\"\"Partial of g wrt sigma\"\"\"\n return (x**2 - 2*x*mu + mu**2) / sigma**3 * g(mu, sigma, x)\n\ndef dg2dx0(x0, y0, sx, sy, x, y):\n \"\"\"Partial of g2 wrt x0\"\"\"\n return g(y0, sy, y) * dgdmu(x0, sx, x)\n\ndef dg2dy0(x0, y0, sx, sy, x, y):\n \"\"\"Partial of g2 wrt y0\"\"\"\n return g(x0, sx, x) * dgdmu(y0, sy, y)\n\ndef dg2dsx(x0, y0, sx, sy, x, y):\n \"\"\"Partial of g2 wrt sx\"\"\"\n return g(y0, sy, y) * dgdsigma(x0, sx, x)\n\ndef dg2dsy(x0, y0, sx, sy, x, y):\n \"\"\"Partial of g2 wrt sy\"\"\"\n return g(x0, sx, x) * dgdsigma(y0, sy, y)\n\ndef dg2sdx0(x0, y0, s, x, y):\n \"\"\"Partial of g2s wrt x0\"\"\"\n return g(y0, s, y) * dgdmu(x0, s, x)\n\ndef dg2sdy0(x0, y0, s, x, y):\n \"\"\"Partial of g2s wrt y0\"\"\"\n return g(x0, s, x) * dgdmu(y0, s, y)\n\ndef dg2sds(x0, y0, s, x, y):\n \"\"\"Partial of g2s wrt s\"\"\"\n return g(x0, s, y) * dgdsigma(y0, s, x) + g(y0, s, y) * dgdsigma(x0, s, x)\n\ndef RM(theta):\n \"\"\"Return 2D (2x2) rotation matrix, with theta counterclockwise rotation in radians\"\"\"\n return np.array([[cos(theta), -sin(theta)],\n [sin(theta), cos(theta)]])\n\n\nclass Poo(object):\n \"\"\"Poo function, works with ndarray inputs\"\"\"\n def __init__(self, a, b, c):\n self.a = a\n self.b = b\n self.c = c\n\n def __call__(self, x):\n \"\"\"Called when self is called as a f'n\"\"\"\n return (1+self.a*x) / (self.b+self.c*x**2)\n\n def __getitem__(self, x):\n \"\"\"Called when self is indexed into\"\"\"\n return self(x)\n\n\ndef hamming(t, N):\n \"\"\"Return y values of Hamming window at sample points t\"\"\"\n #if N == None:\n # N = (len(t) - 1) / 2\n return 0.54 - 0.46 * cos(pi * (2*t + N)/N)\n\ndef hex2rgb(hexcolours):\n \"\"\"Convert colours RGB hex string list into an RGB int array\"\"\"\n hexcolours = toiter(hexcolours)\n rgb = []\n for s in hexcolours:\n s = s[len(s)-6:len(s)] # get last 6 characters\n r, g, b = s[0:2], s[2:4], s[4:6]\n r, g, b = int(r, base=16), int(g, base=16), int(b, base=16)\n rgb.append((r, g, b))\n return np.uint8(rgb)\n\ndef hex2rgba(hexcolours, alpha=255):\n \"\"\"Convert colours RGB hex string list into an RGBA int array\"\"\"\n assert type(alpha) == int and 0 <= alpha <= 255\n rgb = hex2rgb(hexcolours)\n alphas = np.repeat(alpha, len(rgb))\n alphas.shape = -1, 1 # make it 2D column vector\n return np.concatenate([rgb, alphas], axis=1)\n\ndef hex2floatrgba(hexcolours, alpha=255):\n \"\"\"Convert colours RGB hex string list into an RGBA float array\"\"\"\n assert type(alpha) == int and 0 <= alpha <= 255\n rgba = hex2rgba(hexcolours, alpha)\n return np.float64(rgba) / 255.\n\ndef rgb2hex(rgbcolours):\n \"\"\"Convert RGB int array into a hex string list\"\"\"\n rgbcolours = toiter(rgbcolours)\n hx = []\n for rgb in rgbcolours:\n r, g, b = rgb\n h = hex(r*2**16 + g*2**8 + b)\n h = lrstrip(h, '0x', 'L')\n pad = (6 - len(h)) * '0'\n h = '#' + pad + h\n hx.append(h)\n return hx\n\ndef Rx(t):\n \"\"\"Rotation matrix around x axis, theta in radians\"\"\"\n return np.matrix([[1, 0, 0],\n [0, cos(t), -sin(t)],\n [0, sin(t), cos(t)]])\n\ndef Ry(t):\n \"\"\"Rotation matrix around y axis, theta in radians\"\"\"\n return np.matrix([[ cos(t), 0, sin(t)],\n [ 0, 1, 0],\n [-sin(t), 0, cos(t)]])\n\ndef Rz(t):\n \"\"\"Rotation matrix around z axis, theta in radians\"\"\"\n return np.matrix([[cos(t), -sin(t), 0],\n [sin(t), cos(t), 0],\n [ 0, 0, 1]])\n\ndef R(tx, ty, tz):\n \"\"\"Return full 3D rotation matrix, given thetas in degress.\n Mayavi (tvtk actually) rotates axes in Z, X, Y order, for\n some unknown reason. So, we have to do the same. See:\n tvtk_classes.zip/actor.py:32\n tvtk_classes.zip/prop3d.py:67\n \"\"\"\n # convert to radians, then take matrix product\n return Rz(tz*pi/180)*Rx(tx*pi/180)*Ry(ty*pi/180)\n'''\ndef normdeg(angle):\n return angle % 360\n\ndef win2posixpath(path):\n path = path.replace('\\\\', '/')\n path = os.path.splitdrive(path)[-1] # remove drive name from start\n return path\n\ndef oneD2D(a):\n \"\"\"Convert 1D array to 2D array. Can do this just as easily using a[None, :]\"\"\"\n a = a.squeeze()\n assert a.ndim == 1, \"array has more than one non-singleton dimension\"\n a.shape = 1, len(a) # make it 2D\n return a\n\ndef twoD1D(a):\n \"\"\"Convert trivially 2D array to 1D array. Seems unnecessary. Just call squeeze()\"\"\"\n a = a.squeeze()\n assert a.ndim == 1, \"array has more than one non-singleton dimension\"\n return a\n'''\ndef is_unique(a):\n \"\"\"Check whether a has purely unique values in it\"\"\"\n u = np.unique(a)\n if len(a) != len(u):\n return False\n else:\n return True\n\ndef intersect1d(arrays, assume_unique=False):\n \"\"\"Find the intersection of any number of 1D arrays.\n Return the sorted, unique values that are in all of the input arrays.\n Adapted from numpy.lib.arraysetops.intersect1d\"\"\"\n N = len(arrays)\n if N == 0:\n return np.asarray(arrays)\n arrays = list(arrays) # allow assignment\n if not assume_unique:\n for i, arr in enumerate(arrays):\n arrays[i] = np.unique(arr)\n aux = np.concatenate(arrays) # one long 1D array\n aux.sort() # sorted\n if N == 1:\n return aux\n shift = N-1\n return aux[aux[shift:] == aux[:-shift]]\n\ndef rowtake(a, i):\n \"\"\"For each row in a, return values according to column indices in the\n corresponding row in i. Returned shape == i.shape\"\"\"\n assert a.ndim == 2\n assert i.ndim <= 2\n '''\n if i.ndim == 1:\n j = np.arange(a.shape[0])\n else: # i.ndim == 2\n j = np.repeat(np.arange(a.shape[0]), i.shape[1])\n j.shape = i.shape\n j *= a.shape[1]\n j += i\n return a.flat[j]\n '''\n # this is about 3X faster:\n if i.ndim == 1:\n return a[np.arange(a.shape[0]), i]\n else: # i.ndim == 2\n return a[np.arange(a.shape[0])[:, None], i]\n\ndef td2usec(td):\n \"\"\"Convert datetime.timedelta to int microseconds\"\"\"\n sec = td.total_seconds() # float\n usec = intround(sec * 1000000) # round to nearest us\n return usec\n\ndef td2fusec(td):\n \"\"\"Convert datetime.timedelta to float microseconds\"\"\"\n sec = td.total_seconds() # float\n usec = sec * 1000000\n return usec\n\ndef td2days(td):\n \"\"\"Convert datetime.timedelta to days\"\"\"\n sec = td.total_seconds() # float\n days = sec / 3600 / 24\n return days\n\ndef unsortedis(x):\n \"\"\"Return indices of entries in x that are out of order\"\"\"\n x = np.asarray(x)\n try:\n if x.dtype.kind == 'u':\n # x is unsigned int array, risk of int underflow in np.diff\n x = np.int64(x)\n except AttributeError:\n pass # no dtype, not an array\n return np.where(np.diff(x) < 0)[0] # where is the diff between consecutive entries < 0?\n\ndef issorted(x):\n \"\"\"Check if x is sorted\"\"\"\n return len(unsortedis(x)) == 0\n # or, you could compare the array to an explicitly sorted version of itself,\n # and see if they're identical\n\ndef concatenate_destroy(arrs):\n \"\"\"Concatenate list of arrays along 0th axis, destroying them in the process.\n Doesn't duplicate everything in arrays, as does numpy.concatenate. Only\n temporarily duplicates one array at a time, saving memory\"\"\"\n if type(arrs) != list:\n raise TypeError('Arrays must be in a list')\n #arrs = list(arrs) # don't do this! this prevents destruction of the original arrs\n nrows = 0\n subshape = arrs[0].shape[1::] # dims excluding concatenation dim\n dtype = arrs[0].dtype\n # ensure all arrays in arrs are compatible:\n for i, a in enumerate(arrs):\n nrows += len(a)\n if a.shape[1::] != subshape:\n raise TypeError(\"Array %d has subshape %r instead of %r\" %\n (i, a.shape[1::], subshape))\n if a.dtype != dtype:\n raise TypeError(\"Array %d has dtype %r instead of %r\" % (i, a.dtype, dtype))\n subshape = list(subshape)\n shape = [nrows] + subshape\n\n # unlike np.zeros, it seems np.empty doesn't allocate real memory, but does temporarily\n # allocate virtual memory, which is then converted to real memory as 'a' is filled:\n try:\n a = np.empty(shape, dtype=dtype) # empty only allocates virtual memory\n except MemoryError:\n raise MemoryError(\"concatenate_destroy: not enough virtual memory to allocate \"\n \"destination array. Create/grow your swap file?\")\n \n rowi = 0\n for i in range(len(arrs)):\n arr = arrs.pop(0)\n nrows = len(arr)\n a[rowi:rowi+nrows] = arr # concatenate along 0th axis\n rowi += nrows\n return a\n\ndef merged_interval_gen(intervals):\n \"\"\"Generator that merges overlapping (start, stop) intervals.\n Adapted from https://codereview.stackexchange.com/a/108651\"\"\"\n lo, hi = intervals[0] # bounds of the current run of merges\n for interval in intervals[1:]:\n if interval[0] <= hi: # new interval overlaps current run\n hi = max(hi, interval[1]) # merge with the current run\n else: # current run is over\n yield lo, hi # yield accumulated interval\n lo, hi = interval # start new run\n yield lo, hi # end the final run\n\ndef merge_intervals(intervals):\n return list(merged_interval_gen(intervals))\n\ndef nullwavesat(wave, ntwin):\n \"\"\"Null out saturated regions of WaveForm data in-place by replacing them with a linear\n ramp on each channel to minimize sharp edges. Return nx2 2D array of nulled tranges\"\"\"\n nt = wave.data.shape[1] # num timepoints in wave.data\n sattis = wave.satis.any(axis=0) # time only, collapse across all chans\n edges = np.diff(sattis.astype(int)) # find +ve and -ve edges\n onis = np.where(edges > 0)[0] + 1\n offis = np.where(edges < 0)[0] + 1\n if len(onis) - len(offis) == 1:\n offis = np.append(offis, nt) # last off is end of block\n elif len(offis) - len(onis) == 1:\n onis = np.append(onis, 0) # first on is start of block\n # convert to nx2 array, expand window for zeroing around on\n # and off index of each saturation:\n nulltrangeis = np.stack([onis-ntwin, offis+ntwin], axis=1)\n nulltrangeis = np.asarray(merge_intervals(nulltrangeis)) # remove overlap\n nulltrangeis = nulltrangeis.clip(min=0, max=nt-1) # limit to valid index values\n # replace data on each channel with linear ramp from start to end of each\n # time nulltrange:\n for chan in wave.data:\n for nulltrangei in nulltrangeis:\n i, j = nulltrangei\n chan[i:j] = np.linspace(chan[i], chan[j], j-i, dtype=int)\n nulltranges = wave.ts[nulltrangeis] # dereference\n print('Nulled time ranges:')\n print(intround(nulltranges)) # convert to int for better display\n return nulltranges\n\ndef lst2shrtstr(lst, sigfigs=4, brackets=False):\n \"\"\"Return string representation of list, replacing any floats with potentially\n shorter representations with fewer sig figs. Any string items in list will be\n simplified by having their quotes removed\"\"\"\n gnumfrmt = string.join(['%.', str(sigfigs), 'g'], sep='')\n strlst = []\n for val in lst:\n try:\n strlst.append(gnumfrmt % val)\n except TypeError:\n strlst.append(val) # val isn't a general number\n s = string.join(strlst, sep=', ')\n if brackets:\n s = string.join(['[', s, ']'], sep='')\n return s\n\ndef rms(a, axis=None):\n \"\"\"Return root-mean-squared value of array a along axis\"\"\"\n return np.sqrt(np.mean(a**2, axis))\n\ndef rmserror(a, b, axis=None):\n \"\"\"Return root-mean-squared error between arrays a and b\"\"\"\n return rms(a - b, axis=axis)\n\ndef printflush(*args, **kwargs):\n \"\"\"Print args and flush to stdout immediately, so that\n python need not be started in unbuffered mode, or PYTHONUNBUFFERED env need\n not be set. Adapted from https://stackoverflow.com/a/27991478\"\"\"\n file = sys.stdout\n kwargs['file'] = file\n print(*args, **kwargs)\n file.flush()\n\ndef lstrip(s, strip):\n \"\"\"What I think str.lstrip should really do\"\"\"\n if s.startswith(strip):\n return s[len(strip):] # strip it\n else:\n return s\n\ndef rstrip(s, strip):\n \"\"\"What I think str.rstrip should really do\"\"\"\n if s.endswith(strip):\n return s[:-len(strip)] # strip it\n else:\n return s\n\ndef strip(s, strip):\n \"\"\"What I think str.strip should really do\"\"\"\n return rstrip(lstrip(s, strip), strip)\n\ndef lrstrip(s, lstr, rstr):\n \"\"\"Strip lstr from start of s and rstr from end of s\"\"\"\n return rstrip(lstrip(s, lstr), rstr)\n\ndef isascii(c):\n \"\"\"Check if character c is a printable character, TAB, LF, or CR\"\"\"\n try:\n c = ord(c) # convert string character to decimal representation\n except TypeError: # it's already an int? (Py3)\n pass\n return 32 <= c <= 127 or c in [9, 10, 13]\n\ndef rstripnonascii(s):\n \"\"\"Return a new string with all characters after the first non-ASCII character\n stripped from the string\"\"\"\n for i, c in enumerate(s):\n if not isascii(c):\n return s[:i]\n return s\n\ndef matlabize(s):\n \"\"\"Make string s suitable for use as a MATLAB function/script name\"\"\"\n s = s.replace(' ', '_')\n s = s.replace('.', '_')\n s = s.replace('-', '_')\n assert len(s) <= 63 # MATLAB function/script name length limitation\n return s\n\ndef pad(x, align=8):\n \"\"\"Pad x with null bytes so it's a multiple of align bytes long\"\"\"\n if type(x) == str: # or maybe unicode?\n return padstr(x, align=align)\n elif type(x) == np.ndarray:\n return padarr(x, align=align)\n else:\n raise TypeError('Unhandled type %r in pad()')\n\ndef padstr(x, align=8):\n \"\"\"Pad string x with null bytes so it's a multiple of align bytes long.\n Return bytes object\"\"\"\n nbytes = len(x)\n rem = nbytes % align\n npadbytes = align - rem if rem else 0 # nbytes to pad with for 8 byte alignment\n x = x.encode('ascii') # ensure it's pure ASCII, where each char is 1 byte\n if npadbytes == 0:\n return x\n x += NULL * npadbytes # returns a copy, doesn't modify in place\n assert len(x) % align == 0\n return x\n\ndef padarr(x, align=8):\n \"\"\"Flatten array x and pad with null bytes so it's a multiple of align bytes long\"\"\"\n nitems = len(x.ravel())\n nbytes = x.nbytes\n dtypenbytes = x.dtype.itemsize\n rem = nbytes % align\n npadbytes = align - rem if rem else 0 # nbytes to pad with for 8 byte alignment\n if npadbytes == 0:\n return x\n if npadbytes % dtypenbytes != 0:\n raise RuntimeError(\"Can't pad %d byte array to %d byte alignment\" %\n (dtypenbytes, align))\n npaditems = npadbytes / dtypenbytes\n x = x.ravel().copy() # don't modify in place\n # pads with npaditems zeros, each of length dtypenbytes:\n x.resize(nitems + npaditems, refcheck=False)\n assert x.nbytes % align == 0\n return x\n\ndef shiftpad(a, n):\n \"\"\"Horizontally shift 2D array a *in-place* by n points. -ve n shifts\n left, +ve shifts right. Pad with edge values at the appropriate end.\n This is probably the same as np.roll(), except edge values are padded\n instead of wrapped. Also, I think np.roll returns a copy\"\"\"\n assert a.ndim == 2\n assert type(n) == int\n assert n != 0\n if n > 0: # shift right, pad with left edge\n ledge = a[:, 0, None] # keep it 2D (nrows x 1)\n a[:, n:] = a[:, :-n] # throw away right edge\n a[:, 1:n] = ledge # pad with left edge\n else: # n < 0, shift left, pad with right edge\n redge = a[:, -1, None] # keep it 2D (nrows x 1)\n a[:, :n] = a[:, -n:] # throw away left edge\n a[:, n:-1] = redge # pad with right edge\n # no need to return anything\n\ndef rollwin(a, width):\n \"\"\"Return a.nd + 1 dimensional array, where the last dimension contains\n consecutively shifted windows of a of the given width, each shifted by 1\n along the last dimension of a. This allows for calculating rolling stats,\n as well as searching for the existence and position of subarrays in a\n larger array, all without having to resort to Python loops or making\n copies of a.\n\n Taken from:\n http://www.rigtorp.se/2011/01/01/rolling-statistics-numpy.html\n http://stackoverflow.com/questions/7100242/python-numpy-first-occurrence-of-subarray\n http://stackoverflow.com/questions/6811183/rolling-window-for-1d-arrays-in-numpy\n\n Ex 1:\n >>> x = np.arange(10).reshape((2,5))\n >>> rollwin(x, 3)\n array([[[0, 1, 2], [1, 2, 3], [2, 3, 4]],\n [[5, 6, 7], [6, 7, 8], [7, 8, 9]]]) \n >>> np.mean(rollwin(x, 3), -1)\n array([[ 1., 2., 3.],\n [ 6., 7., 8.]])\n\n Ex 2:\n >>> a = np.arange(10)\n >>> np.random.shuffle(a)\n >>> a\n array([7, 3, 6, 8, 4, 0, 9, 2, 1, 5])\n >>> rollwin(a, 3) == [8, 4, 0]\n array([[False, False, False],\n [False, False, False],\n [False, False, False],\n [ True, True, True],\n [False, False, False],\n [False, False, False],\n [False, False, False],\n [False, False, False]], dtype=bool)\n >>> np.all(rollwin(a, 3) == [8, 4, 0], axis=1)\n array([False, False, False, True, False, False, False, False], dtype=bool)\n >>> np.where(np.all(rollwin(a, 3) == [8, 4, 0], axis=1))[0][0]\n 3\n \"\"\"\n shape = a.shape[:-1] + (a.shape[-1] - width + 1, width)\n strides = a.strides + (a.strides[-1],)\n return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)\n\ndef rollwin2D(a, width):\n \"\"\"A modified version of rollwin. Allows for easy columnar search of 2D\n subarray b within larger 2D array a, assuming both have the same number of\n rows.\n \n Ex:\n >>> a\n array([[44, 89, 34, 67, 11, 92, 22, 72, 10, 81],\n [52, 40, 29, 35, 67, 10, 24, 23, 65, 51],\n [70, 58, 14, 34, 11, 66, 47, 68, 11, 56],\n [70, 55, 47, 30, 39, 79, 71, 70, 67, 33]]) \n >>> b\n array([[67, 11, 92],\n [35, 67, 10],\n [34, 11, 66],\n [30, 39, 79]])\n >>> np.where((rollwin2D(a, 3) == b).all(axis=1).all(axis=1))[0]\n array([3])\n \"\"\"\n assert a.ndim == 2\n shape = (a.shape[1] - width + 1, a.shape[0], width)\n strides = (a.strides[-1],) + a.strides\n return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)\n\ndef argcolsubarr2D(a, b):\n \"\"\"Return column index of smaller subarray b within bigger array a. Both\n must be 2D and have the same number of rows. Raises IndexError if b is not\n a subarray of a\"\"\"\n assert a.ndim == b.ndim == 2\n assert a.shape[0] == b.shape[0] # same nrows\n width = b.shape[1] # ncols in b\n return np.where((rollwin2D(a, width) == b).all(axis=1).all(axis=1))[0]\n\ndef lrrep2Darrstripis(a):\n \"\"\"Return left and right slice indices that strip repeated values from all rows\n from left and right ends of 2D array a, such that a[:, lefti:righti] gives you\n the stripped version.\n\n Ex:\n >>> a\n array([[44, 44, 44, 44, 89, 34, 67, 11, 92, 22, 72, 10, 81, 81, 81],\n [52, 52, 52, 52, 40, 29, 35, 67, 10, 24, 23, 65, 51, 51, 51],\n [70, 70, 70, 70, 58, 14, 34, 11, 66, 47, 68, 11, 56, 56, 56],\n [70, 70, 70, 70, 55, 47, 30, 39, 79, 71, 70, 67, 33, 33, 33]])\n >>> lrrep2Darrstripis(a)\n (3, -2)\n \"\"\"\n assert a.ndim == 2\n left = a[:, :1] # 2D column vector\n right = a[:, -1:] # 2D column vector\n leftcolis = argcolsubarr2D(a, left)\n lefti = 0 # at least 1 hit, at the far left edge\n if len(leftcolis) > 1: # multiple hits, get slice index of rightmost consecutive hit\n consecis = np.where(np.diff(leftcolis) == 1)[0]\n if len(consecis) > 0:\n lefti = max(consecis) + 1\n rightcolis = argcolsubarr2D(a, right)\n righti = a.shape[1] # at least 1 hit, at the far right edge\n if len(rightcolis) > 1: # multiple hits, get slice index of leftmost consecutive hit\n consecis = np.where(np.diff(rightcolis)[::-1] == 1)[0]\n if len(consecis) > 0:\n righti = -(max(consecis) + 1)\n return lefti, righti\n\ndef normpdf(p, lapcorrect=1e-10):\n \"\"\"Ensure p is normalized (sums to 1). Return p unchanged if it's already normalized.\n Otherwise, return it normalized. I guess this treats p as a pmf, not strictly a pdf.\n Optional apply Laplacian correction to avoid 0s\"\"\"\n p = np.float64(p) # copy and ensure it's float before modifying in-place\n if lapcorrect and (p == 0).any():\n p += lapcorrect\n psum = p.sum()\n if not np.allclose(psum, 1.0) and psum > 0: # make sure the probs sum to 1\n #print(\"p sums to %f instead of 1, normalizing\" % psum)\n p /= psum\n return p\n\ndef negentropy(x, axis=0):\n \"\"\"Return estimate of negative entropy (and differential entropy) of ndarray x along axis.\n Adapted from Aapo Hyvarinen's mentappr.m dated May 2012, which is based on his NIPS*97\n paper: http://www.cs.helsinki.fi/u/ahyvarin/papers/NIPS97.pdf - \"New approximations of\n differential entropy for independent component analysis and projection pursuit\"\n \"\"\"\n # constants:\n k1 = 36 / (8*np.sqrt(3) - 9)\n gamma = 0.37457\n k2 = 79.047\n # entropy of a standard Gaussian, 1.4189 (in bits? maybe not, since it's natural log):\n gaussianEntropy = np.log(2*pi) / 2 + 0.5\n # normalize to 0 mean and unit variance:\n x = x - x.mean(axis=axis) # don't do this in place\n stdx = x.std(axis=axis)\n x = x / stdx\n\n negentropy = ( k2*((np.log(np.cosh(x))).mean(axis=axis) - gamma)**2 +\n k1*((x*np.exp(-x**2/2)).mean(axis=axis))**2 )\n #diffentropy = gaussianEntropy - negentropy + np.log(stdx)\n return negentropy\n\ndef DKL(p, q):\n \"\"\"Kullback-Leibler divergence from true probability distribution p to arbitrary\n distribution q\"\"\"\n assert len(p) == len(q)\n p, q = normpdf(np.asarray(p)), normpdf(np.asarray(q))\n return sum(p * np.log2(p/q))\n \ndef DJS(p, q):\n \"\"\"Jensen-Shannon divergence, a symmetric measure of divergence between\n distributions p and q\"\"\"\n assert len(p) == len(q)\n p, q = normpdf(np.asarray(p)), normpdf(np.asarray(q))\n m = (p + q) / 2\n return (DKL(p, m) + DKL(q, m)) / 2\n\ndef filter(data, sampfreq=1000, f0=0, f1=7, fr=0.5, gpass=0.01, gstop=30, ftype='ellip'):\n \"\"\"Bandpass filter data on row indices chanis, between f0 and f1 (Hz), with filter\n rolloff (?) fr (Hz).\n\n ftype: 'ellip', 'butter', 'cheby1', 'cheby2', 'bessel'\n \"\"\"\n w0 = f0 / (sampfreq / 2) # fraction of Nyquist frequency == 1/2 sampling rate\n w1 = f1 / (sampfreq / 2)\n wr = fr / (sampfreq / 2)\n if w0 == 0:\n wp = w1\n ws = w1+wr\n elif w1 == 0:\n wp = w0\n ws = w0-wr\n else:\n wp = [w0, w1]\n ws = [w0-wr, w1+wr]\n b, a = scipy.signal.iirdesign(wp, ws, gpass=gpass, gstop=gstop, analog=0, ftype=ftype)\n data = scipy.signal.lfilter(b, a, data)\n return data, b, a\n\ndef filterord(data, sampfreq=1000, f0=300, f1=None, order=4, rp=None, rs=None,\n btype='highpass', ftype='butter', causal=True):\n \"\"\"Bandpass filter data by specifying filter order and btype, instead of gpass and gstop.\n\n btype: 'lowpass', 'highpass', 'bandpass', 'bandstop'\n ftype: 'ellip', 'butter', 'cheby1', 'cheby2', 'bessel'\n\n For 'ellip', need to also specify passband and stopband ripple with rp and rs.\n \"\"\"\n if f0 != None and f1 != None: # both are specified\n assert btype in ['bandpass', 'bandstop']\n fn = np.array([f0, f1])\n elif f0 != None: # only f0 is specified\n assert btype == 'highpass'\n fn = f0\n elif f1 != None: # only f1 is specified\n assert btype == 'lowpass'\n fn = f1\n else: # neither f0 nor f1 are specified\n raise ValueError('At least one of f0 or f1 have to be specified')\n wn = fn / (sampfreq / 2) # wn can be either a scalar or a length 2 vector\n b, a = scipy.signal.iirfilter(order, wn, rp=rp, rs=rs, btype=btype, analog=0,\n ftype=ftype, output='ba')\n if causal:\n data = scipy.signal.lfilter(b, a, data) # causal, adds freq-dependent phase lag\n else:\n data = scipy.signal.filtfilt(b, a, data) # non-causal, 0 phase lag\n return data, b, a\n\ndef WMLDR(data, wname=\"db4\", maxlevel=6, mode='sym'):\n \"\"\"Perform wavelet multi-level decomposition and reconstruction (WMLDR) on multichannel\n data. See Wiltschko2008. Default to Daubechies(4) wavelet. Modifies data in-place, at\n least for now. The effective cutoff frequency is:\n\n fc = (sampfreq / 2) / 2**maxlevel (Wiltschko2008)\n\n For sampfreq of 25 kHz and maxlevel of 6, the effective cutoff frequency is 195 Hz.\n For sampfreq of 30 kHz and maxlevel of 6, the effective cutoff frequency is 234 Hz.\n\n TODO: for now, this only returns highpass data. In the future, this probably should\n return both low and highpass data (and not modify it in-place). The Discussion in\n Wiltschko2008 suggests that this approach cannot be used to extract the LFP, but\n I don't see why you can't simply subtract the highpass data from the raw data to get the\n lowpass data.\n\n Signal extension modes (from PyWavelets docs):\n\n PyWavelets provides several methods of signal extrapolation that can be used to minimize\n edge effects. PyWavelet's default is 'sym':\n\n zpd - zero-padding - signal is extended by adding zero samples:\n ... 0 0 | x1 x2 ... xn | 0 0 ...\n\n cpd - constant-padding - border values are replicated:\n ... x1 x1 | x1 x2 ... xn | xn xn ...\n\n sym - symmetric-padding - signal is extended by mirroring samples:\n ... x2 x1 | x1 x2 ... xn | xn xn-1 ...\n\n ppd - periodic-padding - signal is treated as a periodic one:\n ... xn-1 xn | x1 x2 ... xn | x1 x2 ...\n\n sp1 - smooth-padding - signal is extended according to the first derivatives calculated on\n the edges (straight line)\n\n DWT performed for these extension modes is slightly redundant, but ensures perfect\n reconstruction. To receive the smallest possible number of coefficients, computations can\n be performed with the periodization mode:\n\n per - periodization - is like periodic-padding but gives the smallest possible number of\n decomposition coefficients. IDWT must be performed with the same mode.\n \"\"\"\n import pywt\n\n data = np.atleast_2d(data)\n nt = data.shape[1]\n # reconstructed signals always seem to have an even number of points. If the number of\n # input data points is odd, trim last data point from reconstructed signal:\n isodd = nt % 2\n # filter data in place, iterate over channels in rows:\n nchans = len(data)\n for chani in range(nchans):\n # decompose the signal:\n cs = pywt.wavedec(data[chani], wname, mode=mode, level=maxlevel)\n # destroy the appropriate approximation coefficients to get highpass data:\n cs[0] = None\n # reconstruct the signal:\n recsignal = pywt.waverec(cs, wname, mode=mode)\n ntrec = len(recsignal)\n data[chani] = recsignal[:ntrec-isodd]\n \n return data\n\ndef envelope_hilbert(x):\n \"\"\"Return envelope of signal x by taking abs of hilbert transform of x. Note this\n only really works for narrow-band signals. Otherwise, the output envelope is almost\n as noisy as the input.\n See:\n https://dsp.stackexchange.com/a/3464\n https://docs.scipy.org/doc/scipy-0.19.0/reference/generated/scipy.signal.hilbert.html\n \"\"\"\n return np.abs(scipy.signal.hilbert(x))\n\ndef envelope_filt(x, sampfreq=None, f0=None, f1=BWLPF1, order=BWLPORDER, ftype='butter',\n causal=False):\n \"\"\"Calculate envelope of x by rectifying and then low-pass filtering. Return float64\"\"\"\n assert sampfreq is not None\n x = np.abs(x)\n x, b, a = filterord(x, sampfreq=sampfreq, f0=f0, f1=f1,\n order=order, rp=None, rs=None,\n btype='lowpass', ftype=ftype, causal=causal) # float64\n return x\n\ndef poly_between(x, ylower, yupper):\n \"\"\"Return the polygon that fills the regions between ylower and yupper, at the x.\n All 3 arguments must have the same length.\n\n Return values are x, y arrays for use with `matplotlib.axes.Axes.fill()`\n\n Adapted from deprecated `matplotlib.mlab.poly_between()`:\n https://matplotlib.org/api/mlab_api.html#matplotlib.mlab.poly_between\n \"\"\"\n assert len(x) == len(ylower) == len(yupper)\n # go in one direction for upper values, then opposite direction for lower values:\n x = np.concatenate((x, x[::-1]))\n y = np.concatenate((yupper, ylower[::-1]))\n return x, y\n\ndef updatenpyfilerows(fname, rows, arr):\n \"\"\"Given a numpy formatted binary file (usually with .npy extension,\n but not necessarily), update 0-based rows (first dimension) of the\n array stored in the file from arr. Works for arrays of any rank >= 1\"\"\"\n assert len(arr) >= 1 # has at least 1 row\n with open(fname, 'r+b') as f: # open in read+write binary mode\n # get .npy format version:\n major, minor = np.lib.format.read_magic(f)\n assert (major == 1 and minor == 0)\n # read header to move file pointer to start of array in file:\n shape, fortran_order, dtype = np.lib.format.read_array_header_1_0(f)\n assert shape == arr.shape\n assert fortran_order == np.isfortran(arr)\n assert dtype == arr.dtype\n arroffset = f.tell()\n rowsize = arr[0].size * dtype.itemsize # nbytes per row\n # sort rows so that we move efficiently from start to end of file:\n rows = sorted(rows) # rows might be a set, list, tuple, or array, convert to list\n # update rows in file:\n for row in rows:\n f.seek(arroffset + row*rowsize) # seek from start of file, row is 0-based\n f.write(arr[row])\n\n\nclass SpykeUnpickler(pickle.Unpickler):\n\n def find_class(self, oldmod, oldcls):\n \"\"\"Required for unpickling some .sort files and upgrading them to the next version.\n Rename class and module names that changed between two .sort versions. Unfortunately,\n we can't check the .sort version number until after unpickling, so this has to be done\n for *all* .sort files during unpickling, not after\"\"\"\n oldmod2newmod = {'core': 'stream'} # version 0.7 to 0.8\n oldcls2newcls = {'Stream': 'SurfStream', # 0.7 to 0.8\n 'SimpleStream': 'SimpleStream', # 0.7 to 0.8\n 'TrackStream': 'MultiStream', # 0.7 to 0.8\n 'A1x64_Poly2_6mm_23s_160': 'A1x64'} # 1.2 to 1.3\n try:\n newcls = oldcls2newcls[oldcls]\n except KeyError: # no old to new class conversion\n exec('import %s' % oldmod)\n return eval('%s.%s' % (oldmod, oldcls))\n newmod = oldmod2newmod.get(oldmod, oldmod)\n print('Rename on unpickle: %s.%s -> %s.%s' % (oldmod, oldcls, newmod, newcls))\n exec('import %s' % newmod)\n return eval('%s.%s' % (newmod, newcls))\n\ndef arr2json(arr, indent=0, ndec=6, max_line_width=75):\n \"\"\"Convert numpy.ndarray to string suitable for json list. Much nicer formatting\n than Python list. Indent all but the first line with indent spaces\"\"\"\n assert type(arr) == np.ndarray\n fltfmt = \"%.\" + str(ndec) + 'f'\n max_line_width = max_line_width - indent\n s = np.array2string(arr, separator=', ', threshold=np.inf, max_line_width=max_line_width,\n formatter={'float_kind':lambda x: fltfmt % x})\n indentstr = indent * ' '\n if indent:\n sl = s.splitlines()\n nlines = len(sl)\n for linei in range(1, nlines):\n sl[linei] = indentstr + sl[linei]\n s = '\\n'.join(sl)\n return s\n\ndef write_dat_json(stream, fulljsonfname, sampfreq=None, chans=None, auxchans=None,\n chan_order=None, envelope=None, gaps=False,\n tranges=None, nulltranges=None):\n \"\"\"Write .json metadata file as a companion to stream's file. For now, stream should be\n either a DATStream, NSXStream, or SurfStream\"\"\"\n ext = stream.ext\n assert ext in ['.dat', '.ns6', '.srf']\n if stream.is_multi(): # it's a MultiStream\n source_fnames = stream.fnames\n stream = stream.streams[0] # use its first stream to get field values\n else: # it's a single Stream\n source_fnames = [stream.fname]\n fh = stream.f.fileheader\n\n # choose values:\n if sampfreq is None:\n sampfreq = stream.sampfreq\n sample_rate = sampfreq\n if chans is None:\n chans = stream.chans # array\n if auxchans is None:\n auxchans = np.array([])\n nchans = len(chans) + len(auxchans)\n uV_per_AD = stream.converter.AD2uV(1)\n try:\n adaptername = stream.adaptername\n except AttributeError:\n adaptername = None # converts to json null\n # multiply by sampfreq instead of dividing by stream.tres, because passed sampfreq\n # might differ from that of stream:\n nsamples_offset = intround(stream.t0 / 1e6 * sampfreq)\n datetime = stream.datetime.isoformat()\n if ext == '.dat':\n author = fh.author\n version = fh.version\n notes = fh.notes\n elif ext == '.ns6':\n author = 'Blackrock NSP'\n version = ''\n notes = fh.comment\n elif ext == '.srf':\n author = fh.user_name\n version = fh.app_info\n notes = ''\n else:\n raise ValueError\n if tranges is None:\n tranges = stream.tranges # 2D\n if nulltranges is None:\n nulltranges = np.array([]) # normally would be 2D\n filtering = stream.filtering\n common_avg_ref = stream.car\n\n # write to odict:\n od = odict()\n od['nchans'] = nchans\n od['sample_rate'] = sample_rate\n if ext == '.srf':\n od['shcorrect'] = stream.shcorrect\n od['dtype'] = 'int16' # hard-coded, only dtype supported for now\n od['uV_per_AD'] = uV_per_AD\n od['probe_name'] = stream.probe.name\n od['adapter_name'] = adaptername\n od['chans'] = 'CHANSPLACEHOLDER' # array\n od['chan_order'] = chan_order # for human reference only, 'depth' & None are obvious values\n od['aux_chans'] = 'AUXCHANSPLACEHOLDER' # array\n od['nsamples_offset'] = nsamples_offset\n od['datetime'] = datetime\n od['author'] = author\n od['version'] = version\n od['notes'] = notes\n\n od['source_fnames'] = source_fnames\n if len(source_fnames) > 1:\n od['gaps'] = gaps # only meaningful for MultiStream with more than one Stream\n od['tranges'] = 'TRANGESPLACEHOLDER' # 2D array\n od['nulltranges'] = 'NULLTRANGESPLACEHOLDER' # 2D array\n\n od['filtering'] = filtering\n od['common_avg_ref'] = common_avg_ref\n if envelope:\n od['envelope'] = envelope\n\n # convert odict to json string, end with a blank line:\n indent = 1\n s = json.dumps(od, indent=indent) + '\\n'\n # swap array placeholders with nicely formatted array reprs:\n s = s.replace('\"CHANSPLACEHOLDER\"', arr2json(chans, indent=indent+9))\n s = s.replace('\"AUXCHANSPLACEHOLDER\"', arr2json(auxchans, indent=indent+13))\n s = s.replace('\"TRANGESPLACEHOLDER\"', arr2json(tranges, indent=indent+11))\n s = s.replace('\"NULLTRANGESPLACEHOLDER\"', arr2json(nulltranges, indent=indent+15))\n # write to file:\n with open(fulljsonfname, 'w') as jsonf:\n jsonf.write(s)\n print('Wrote metadata file %r' % fulljsonfname)\n\ndef write_ks2_chanmap_mat(stream, fname):\n \"\"\"Write stream's channel map information to .mat file for use by Kilosort2\"\"\"\n nchans = stream.nchans # number of enabled chans\n # mask to tell Kilosort2 which chans in .dat to use for sorting?:\n connected = np.tile(True, (nchans, 1)) # column vector\n chans = stream.chans # array of enabled chans\n # row vector, 1-based indices into coords, in order of data in .dat\n chanMap = np.arange(1, nchans+1)\n chanMap0ind = chanMap - 1 # 0-based version of chanMap\n # get coords of only the enabled chans, will be indexed into by chanMap in MATLAB:\n coords = np.asarray([ stream.probe.SiteLoc[chan] for chan in chans ])\n xcoords = coords[:, 0].reshape(-1, 1) # column vector\n ycoords = coords[:, 1].reshape(-1, 1) # column vector, origin is at top of probe\n ycoords = ycoords.max() - ycoords # Kilosort2 expects origin at bottom of probe\n kcoords = np.tile(1, (nchans, 1)) # column vector, something to do with shanks?\n fs = stream.rawsampfreq\n \"\"\"\n Export to .mat file with exactly the same dtypes (doubles) that Kilosort2's chanmap\n creation script (see .m files in templates/Kilosort2) does. Note that this saves to a\n MATLAB 5 (to version 7.2) .mat file, while by default contemporary MATLAB saves to the\n newer HDF5 version, which is unsupported by scipy.io. Both seem to load identically in\n MATLAB 2015a, so it shouldn't matter:\n \"\"\"\n matd = {'connected': connected, # leave as boolean\n 'chanMap': np.float64(chanMap),\n 'chanMap0ind': np.float64(chanMap0ind),\n 'xcoords': np.float64(xcoords),\n 'ycoords': np.float64(ycoords),\n 'kcoords': np.float64(kcoords),\n 'fs': np.float64(fs)}\n scipy.io.savemat(fname, matd)\n print('Wrote Kilosort2 chanmap file %r' % fname)\n\n\n## TODO: these should be deprecated after moving to Py3 and/or Qt5:\n\ndef qvar2list(qvar):\n \"\"\"Convert Py2 + Qt4 QVariant to a list\"\"\"\n try:\n return qvar.toList() # Py2 + Qt4\n except AttributeError:\n return qvar # Py3 and/or Qt5\n\ndef qvar2str(qvar):\n \"\"\"Convert Py2 + Qt4 QVariant to a string\"\"\"\n try:\n return str(qvar.toString()) # Py2 + Qt4\n except AttributeError:\n return str(qvar) # Py3 and/or Qt5\n\ndef qvar2int(qvar):\n \"\"\"Convert Py2 + Qt4 QVariant to an int\"\"\"\n try:\n return qvar.toInt()[0] # Py2 + Qt4\n except AttributeError:\n return qvar # Py3 and/or Qt5\n"
] | [
[
"numpy.dot",
"numpy.median",
"numpy.where",
"numpy.sort",
"sklearn.decomposition.SparsePCA",
"numpy.concatenate",
"numpy.histogram",
"numpy.linalg.norm",
"sklearn.decomposition.MiniBatchSparsePCA",
"sklearn.decomposition.NMF",
"numpy.arange",
"numpy.savez_compressed",
"numpy.sqrt",
"numpy.column_stack",
"sklearn.decomposition.FastICA",
"scipy.signal.find_peaks",
"sklearn.decomposition.PCA",
"numpy.array",
"numpy.savetxt",
"numpy.zeros",
"sklearn.manifold.TSNE",
"numpy.diff",
"numpy.float64",
"numpy.float32",
"numpy.uint64",
"numpy.intersect1d",
"numpy.hstack",
"numpy.setdiff1d",
"numpy.asarray",
"numpy.union1d",
"numpy.split",
"numpy.any",
"numpy.abs",
"numpy.all",
"numpy.int64",
"numpy.unique"
],
[
"numpy.lib.stride_tricks.as_strided",
"numpy.random.choice",
"numpy.set_printoptions",
"numpy.tile",
"numpy.exp",
"numpy.mean",
"numpy.where",
"numpy.cos",
"matplotlib.rcParams.get",
"numpy.concatenate",
"numpy.uint8",
"numpy.sin",
"numpy.empty",
"numpy.log",
"numpy.seterr",
"numpy.lib.format.read_array_header_1_0",
"numpy.lib.format.read_magic",
"numpy.prod",
"numpy.arange",
"numpy.sqrt",
"numpy.append",
"numpy.in1d",
"numpy.atleast_2d",
"numpy.array",
"numpy.setxor1d",
"numpy.zeros",
"numpy.round",
"numpy.isfortran",
"numpy.diff",
"numpy.float64",
"numpy.allclose",
"numpy.float32",
"numpy.stack",
"numpy.log2",
"numpy.array2string",
"numpy.floor",
"numpy.ceil",
"numpy.asarray",
"numpy.union1d",
"numpy.cosh",
"numpy.ravel",
"numpy.abs",
"numpy.int64",
"numpy.linspace",
"numpy.unique"
]
] |
emmettmeinzer/hmwgen | [
"cd47733b5a34a6a3a9b56026eb5e73069e398033",
"cd47733b5a34a6a3a9b56026eb5e73069e398033"
] | [
"archive/reuUpdated.py",
"archive/attention.py"
] | [
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Mon Nov 11 13:41:14 2019\r\n\r\n@author: Emmett & Binyang\r\n\"\"\"\r\n\r\nfrom pprint import pprint\r\nimport pandas as pd\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nimport seaborn as sns\r\nfrom nltk.tokenize.punkt import PunktSentenceTokenizer, PunktTrainer\r\n\r\n##Let’s first build a corpus to train our tokenizer on. We’ll use stuff available in NLTK:\r\n\r\nfrom nltk.corpus import gutenberg\r\n\r\n# print (dir(gutenberg))\r\n# print (gutenberg.fileids())\r\n\r\ntext = \"\"\r\nfor file_id in gutenberg.fileids():\r\n text += gutenberg.raw(file_id)\r\n \r\nprint (len(text))\r\n\r\n##a funtion that converts a list to a string\r\ndef listToString(s): \r\n \r\n # initialize an empty string \r\n str1 = \"\" \r\n \r\n # traverse in the string \r\n for ele in s: \r\n str1 += ele \r\n \r\n # return string \r\n return str1\r\n\r\n##extract sentences from samples for following sentiment analysis\r\nsampNum = 1\r\nsent_df = pd.DataFrame()\r\ni = 0\r\n\r\nwhile (sampNum < 186):\r\n fileOpen = open(\"sample\"+str(sampNum)+\".txt\",\"r\")\r\n temp = fileOpen.readlines()\r\n temp = listToString(temp)\r\n \r\n trainer = PunktTrainer()\r\n trainer.INCLUDE_ALL_COLLOCS = True\r\n trainer.train(text)\r\n tokenizer = PunktSentenceTokenizer(trainer.get_params())\r\n \r\n ##Adding more abbreviations\r\n tokenizer._params.abbrev_types.add('dr')\r\n \r\n sent = tokenizer.tokenize(temp)\r\n \r\n for sent in sent:\r\n sent_df.loc[i, 'sent'] = sent\r\n sent_df.loc[i, 'sample'] = sampNum\r\n i += 1\r\n \r\n sampNum += 1\r\n\r\n##NLTK’s built-in Vader Sentiment Analyzer will simply rank a piece of text as positive, negative or neutral \r\n##using a lexicon of positive and negative words.\r\n\r\n##We can utilize this tool by first creating a Sentiment Intensity Analyzer (SIA) to categorize our headlines, \r\n##then we'll use the polarity_scores method to get the sentiment.\r\n\r\n##We'll append each sentiment dictionary to a results list, which we'll transform into a dataframe:\r\n\r\nfrom nltk.sentiment.vader import SentimentIntensityAnalyzer as SIA\r\n\r\nsia = SIA()\r\nresults = []\r\n\r\nfor idx, row in sent_df.iterrows():\r\n line = row['sent']\r\n score = sia.polarity_scores(line)\r\n sent_df.loc[idx, 'neg'] = score.get('neg')\r\n sent_df.loc[idx, 'neu'] = score.get('neu')\r\n sent_df.loc[idx, 'pos'] = score.get('pos')\r\n sent_df.loc[idx, 'compound'] = score.get('compound')\r\n\r\n# pprint(results[:10], width=100)\r\n\r\n##We will consider posts with a compound value greater than 0.2 as positive and less than -0.2 as negative. \r\n##There's some testing and experimentation that goes with choosing these ranges, and there is a trade-off to be \r\n##made here. If you choose a higher value, you might get more compact results (less false positives and false \r\n##negatives), but the size of the results will decrease significantly.\r\n\r\nsent_df['label'] = 0\r\nsent_df.loc[sent_df['compound'] > 0.3, 'label'] = 1\r\nsent_df.loc[sent_df['compound'] < -0.3, 'label'] = -1\r\n# sent_df.head()\r\n\r\n##We have all the data we need to save, so let's do that:\r\n\r\nsent_df.to_csv('sentiment analysis.csv', mode='a', encoding='utf-8', index=False)\r\n\r\n##We can now keep appending to this csv, but just make sure that if you reassign the headlines set, you could get \r\n##duplicates. Maybe add a more advanced saving function that reads and removes duplicates before saving.\r\n\r\n#Let's first take a peak at a few positive and negative headlines:\r\n\r\nprint(\"Positive headlines:\\n\")\r\npprint(list(sent_df[sent_df['label'] == 1].sent)[:5], width=200)\r\n\r\nprint(\"\\nNegative headlines:\\n\")\r\npprint(list(sent_df[sent_df['label'] == -1].sent)[:5], width=200)\r\n\r\n##Now let's check how many total positives and negatives we have in this dataset:\r\n\r\nprint(sent_df.label.value_counts())\r\nprint(sent_df.label.value_counts(normalize=True) * 100)\r\n\r\n##The first line gives us raw value counts of the labels, whereas the second line provides percentages \r\n##with the normalize keyword.\r\n\r\n##For fun, let's plot a bar chart:\r\n\"\"\"\r\nfig, ax = plt.subplots(figsize=(8, 8))\r\n\r\ncounts = sent_df.label.value_counts(normalize=True) * 100\r\n\r\nsns.barplot(x=counts.index, y=counts, ax=ax)\r\n\r\nax.set_xticklabels(['Negative', 'Neutral', 'Positive'])\r\nax.set_ylabel(\"Percentage\")\r\n\r\nplt.show()\r\n\"\"\"\r\n\r\n##filter the sentences by number of words in it\r\nfor idx, row in sent_df.iterrows():\r\n sentence = row['sent']\r\n sent_df.loc[idx, 'len_sent'] = len(sentence.split())\r\n\r\n##split positive and other sentences\r\npos = sent_df[sent_df['label'] == 1]\r\nneg = sent_df[sent_df['label'] != 1]\r\n\r\nimport gensim\r\nfrom gensim.parsing.preprocessing import strip_non_alphanum\r\nfrom gensim.parsing.preprocessing import strip_punctuation\r\nfrom gensim.parsing.preprocessing import strip_multiple_whitespaces\r\nfrom gensim.parsing.preprocessing import stem_text\r\n\r\ncorpus_full = []\r\nfor idx, row in sent_df.iterrows():\r\n temp = row['sent']\r\n temp1 = strip_non_alphanum(str(temp))\r\n temp2 = strip_punctuation(temp1)\r\n temp3 = strip_multiple_whitespaces(temp2)\r\n final = stem_text(temp3)\r\n corpus_full.append(final)\r\n\r\ncorpus_pos = []\r\nfor idx, row in pos.iterrows():\r\n temp = row['sent']\r\n temp1 = strip_non_alphanum(str(temp))\r\n temp2 = strip_punctuation(temp1)\r\n temp3 = strip_multiple_whitespaces(temp2)\r\n final = stem_text(temp3)\r\n corpus_pos.append(final)\r\n \r\ncorpus_neg = []\r\nfor idx, row in neg.iterrows():\r\n temp = row['sent']\r\n temp1 = strip_non_alphanum(str(temp))\r\n temp2 = strip_punctuation(temp1)\r\n temp3 = strip_multiple_whitespaces(temp2)\r\n final = stem_text(temp3)\r\n corpus_neg.append(final)\r\n\r\nfrom nltk.corpus import stopwords\r\nstop_words = stopwords.words('english')\r\n\r\nstoplist = set('a about above after again against all am an and any are arent\\\r\n as also at be because been before being below between both but\\\r\n by cant cannot could couldnt did didnt do does doesnt doing dont\\\r\n down during each els few for from further had hadnt has have havent\\\r\n having he hed hes her here heres hers herself him himself his\\\r\n how hows i id ill im ive if in into is isnt it its itself lets\\\r\n me more most mustnt my myself no nor not of off on once only or\\\r\n other ought our ours ourselves out over own same shant she shes\\\r\n should shouldnt so some such than that thats the their theirs\\\r\n them themselves then there theres these they theyd theyll theyre\\\r\n theyve this those through to too under until up very was wasnt\\\r\n we wed were weve were werent what whats when whens which while\\\r\n who whos whom why whys with wont would wouldnt you youd youll\\\r\n youre youve your yours yourself yourselves ll ve s ar mayb ha re\\\r\n us thi isn a b c d e f g h i j k l m n o p q r s t u v w x y z\\\r\n hi will can get back go don wa let atc ok ani mi thei whenev make\\\r\n just take aw know sai good baltimor jetblu lol thank thanks like\\\r\n vari might less highest billion nice probabl lot fuck shit sure\\\r\n feel dure befor realli work veri chanc see awai onc onli dy aren\\\r\n 100 someth thing even happen becaus wai everi much help want think\\\r\n fear flight plane fly mai time dai\\\r\n 1 2 3 4 5 6 7 8 9 10'.split())\r\n\r\nprint (len(stoplist))\r\nstoplist.update(stop_words)\r\n\r\nprint(len(stop_words))\r\nprint(len(stoplist))\r\n\r\n#standardize text -- makes all characters lowercase and removes common stop words\r\ntext_full = [[word for word in document.lower().split() if word not in stoplist]\r\n for document in corpus_full]\r\nprint(text_full)\r\ntext_pos = [[word for word in document.lower().split() if word not in stoplist]\r\n for document in corpus_pos]\r\ntext_neg = [[word for word in document.lower().split() if word not in stoplist]\r\n for document in corpus_neg]\r\n\r\n#count number of times that word appears in corpus\r\n#pair frequency with respective word in new array\r\nfrom collections import defaultdict\r\n\r\nfrequency = defaultdict(int)\r\nfor text in text_full:\r\n for token in text:\r\n frequency[token] += 1\r\n\r\ncorpus_removeOne_full = [[token for token in text if frequency[token]>1] for text in text_full]\r\n\r\nfrequency = defaultdict(int)\r\nfor text in text_pos:\r\n for token in text:\r\n frequency[token] += 1\r\n \r\ncorpus_removeOne_pos = [[token for token in text if frequency[token]>1] for text in text_pos]\r\n\r\nfrequency = defaultdict(int)\r\nfor text in text_neg:\r\n for token in text:\r\n frequency[token] += 1\r\n \r\ncorpus_removeOne_neg = [[token for token in text if frequency[token]>1] for text in text_neg]\r\n\r\n\r\nfrom gensim import corpora\r\n#add corpora to dictionary\r\ndictionary_full = corpora.Dictionary(corpus_removeOne_full)\r\ndictionary_pos = corpora.Dictionary(corpus_removeOne_pos)\r\ndictionary_neg = corpora.Dictionary(corpus_removeOne_neg)\r\n#save dictionary for future reference\r\ndictionary_full.save('redditTest_full.dict')\r\ndictionary_pos.save('redditTest_pos.dict') #location of document in computer\r\ndictionary_neg.save('redditTest_neg.dict')\r\n#dict = gensim.corpora.Dictionary.load('redditTest.dict')\r\n\r\n#assign numeric id to each token in dictionary\r\ndictID_full = dictionary_full.token2id\r\ndictID_pos = dictionary_pos.token2id\r\ndictID_neg = dictionary_neg.token2id\r\n\r\n#remove empty sentences\r\nfor text in corpus_removeOne_full:\r\n if len(text) == 0:\r\n corpus_removeOne_full.remove(text)\r\n\r\nfor text in corpus_removeOne_pos:\r\n if len(text) == 0:\r\n corpus_removeOne_pos.remove(text)\r\n \r\nfor text in corpus_removeOne_neg:\r\n if len(text) == 0:\r\n corpus_removeOne_neg.remove(text)\r\n\r\n\r\n#converts each word into vector following same process as example\r\n#Bag of Word Corpus of Full Sentiment\r\nbow_corpus_full = [dictionary_full.doc2bow(text) for text in corpus_removeOne_full]\r\ncorpora.MmCorpus.serialize('redditTest_full.mm', bow_corpus_full)\r\ncorp_full = gensim.corpora.MmCorpus('redditTest_full.mm')\r\n\r\nfrom gensim import models\r\ntfidf_pos = models.TfidfModel(bow_corpus_full)\r\ncorpus_tfidf_full = tfidf_pos[bow_corpus_full]\r\n\r\n#Bag of Word Corpus of Positive Sentiment\r\nbow_corpus_pos = [dictionary_pos.doc2bow(text) for text in corpus_removeOne_pos]\r\ncorpora.MmCorpus.serialize('redditTest_pos.mm', bow_corpus_pos)\r\ncorp_pos = gensim.corpora.MmCorpus('redditTest_pos.mm')\r\n\r\nfrom gensim import models\r\ntfidf_pos = models.TfidfModel(bow_corpus_pos)\r\ncorpus_tfidf_pos = tfidf_pos[bow_corpus_pos]\r\n\r\n#Bag of Word Corpus of Negative Sentiment\r\nbow_corpus_neg = [dictionary_neg.doc2bow(text) for text in corpus_removeOne_neg]\r\ncorpora.MmCorpus.serialize('redditTest_neg.mm', bow_corpus_neg)\r\ncorp_neg = gensim.corpora.MmCorpus('redditTest_neg.mm')\r\n\r\nfrom gensim import models\r\ntfidf_neg = models.TfidfModel(bow_corpus_neg)\r\ncorpus_tfidf_neg = tfidf_neg[bow_corpus_neg]\r\n\r\n\r\n#LDA Mallet for full corpus\r\nmallet_path = '/Users/emmet/.spyder-py3-dev/REU_Project/mallet-2.0.8/bin/mallet'\r\nlda_full = gensim.models.wrappers.LdaMallet(mallet_path, corpus=bow_corpus_full, num_topics=9, id2word=dictionary_full, workers=1, alpha=110, random_seed=109, iterations=50)\r\ncorpus_LDA_full = lda_full[bow_corpus_full]\r\nlda_full.print_topics(9)\r\n\r\n#LDA Mallet for positive corpus\r\nmallet_path = '/Users/emmet/.spyder-py3-dev/REU_Project/mallet-2.0.8/bin/mallet'\r\nlda_pos = gensim.models.wrappers.LdaMallet(mallet_path, corpus=bow_corpus_pos, num_topics=9, id2word=dictionary_pos, workers=1, alpha=110, random_seed=109, iterations=50)\r\ncorpus_LDA_pos = lda_pos[bow_corpus_pos]\r\nlda_pos.print_topics(9)\r\n\r\n#LDA Mallet for negative corpus\r\nmallet_path = '/Users/emmet/.spyder-py3-dev/REU_Project/mallet-2.0.8/bin/mallet'\r\nlda_neg = gensim.models.wrappers.LdaMallet(mallet_path, corpus=bow_corpus_neg, num_topics=9, id2word=dictionary_neg, workers=1, alpha=110, random_seed=109, iterations=50)\r\ncorpus_LDA_neg = lda_neg[bow_corpus_neg]\r\nlda_neg.print_topics(9)\r\n\r\n\r\nimport pandas as pd\r\nimport matplotlib.pyplot as plt\r\nimport matplotlib.colors as mcolors\r\nfrom sklearn.manifold import TSNE\r\n\r\ncolors = np.array([color for name, color in mcolors.TABLEAU_COLORS.items()])\r\n\r\n#t-SNE plot for full corpus\r\nn_topics = 9\r\ntopic_weights_full = []\r\nfor row_list in lda_full[bow_corpus_full]:\r\n tmp = np.zeros(n_topics)\r\n for i, w in row_list:\r\n tmp[i] = w\r\n topic_weights_full.append(tmp)\r\n \r\narr_full = pd.DataFrame(topic_weights_full).fillna(9).values\r\ntopic_num_full = np.argmax(arr_full, axis=1)\r\ntsne_model_full = TSNE(n_components=3, random_state=None, method='barnes_hut', \r\n angle=0.5, init='pca')\r\ntsne_lda_full = tsne_model_full.fit_transform(arr_full)\r\n\r\nsub = str.maketrans(\"0123456789\", \"₀₁₂₃₄₅₆₇₈₉\")\r\nplt.xlabel('t-SNE1'.translate(sub))\r\nplt.ylabel('t-SNE2'.translate(sub))\r\nplt.title('t-SNE Plot of Topics within Positive Sentiment Corpus')\r\ntsne_full = plt.scatter(x=tsne_lda_full[:,0], y=tsne_lda_full[:,1])\r\nplt.show(tsne_full)\r\n\r\n\"\"\"\r\n#t-SNE plot for positive corpus\r\nn_topics = 9\r\ntopic_weights_pos = []\r\nfor row_list in lda_pos[bow_corpus_pos]:\r\n tmp = np.zeros(n_topics)\r\n for i, w in row_list:\r\n tmp[i] = w\r\n topic_weights_pos.append(tmp)\r\n \r\narr_pos = pd.DataFrame(topic_weights_pos).fillna(0).values\r\ntopic_num_pos = np.argmax(arr_pos, axis=1)\r\ntsne_model_pos = TSNE(n_components=3, random_state=None, method='barnes_hut', \r\n angle=0.5, init='pca')\r\ntsne_lda_pos = tsne_model_pos.fit_transform(arr_pos)\r\n\r\nsub = str.maketrans(\"0123456789\", \"₀₁₂₃₄₅₆₇₈₉\")\r\nplt.xlabel('t-SNE1'.translate(sub))\r\nplt.ylabel('t-SNE2'.translate(sub))\r\nplt.title('t-SNE Plot of Topics within Positive Sentiment Corpus')\r\ntsne_pos = plt.scatter(x=tsne_lda_pos[:,0], y=tsne_lda_pos[:,1])\r\n#plt.show(tsne_pos)\r\n\r\n\r\n#t-SNE plot for negative corpus\r\nn_topics = 9\r\ntopic_weights_neg = []\r\nfor row_list in lda_neg[bow_corpus_neg]:\r\n tmp = np.zeros(n_topics)\r\n for i, w in row_list:\r\n tmp[i] = w\r\n topic_weights_neg.append(tmp)\r\n \r\narr_neg = pd.DataFrame(topic_weights_neg).fillna(0).values\r\ntopic_num_neg = np.argmax(arr_neg, axis=1)\r\ntsne_model_neg = TSNE(n_components=3, random_state=None, method='barnes_hut', \r\n angle=0.5, init='pca')\r\ntsne_lda_neg = tsne_model_neg.fit_transform(arr_neg)\r\n\r\nsub = str.maketrans(\"0123456789\", \"₀₁₂₃₄₅₆₇₈₉\")\r\nplt.xlabel('t-SNE1'.translate(sub))\r\nplt.ylabel('t-SNE2'.translate(sub))\r\nplt.title('t-SNE Plot of Topics within Negative Sentiment Corpus')\r\ntsne_neg = plt.scatter(tsne_lda_neg[:,0], tsne_lda_neg[:,1])\r\n#plt.show(tsne_neg)\r\n\"\"\"\r\n\r\nfrom collections import Counter\r\n#Word Count & Keyword for Full Corpus\r\ntopics_full = lda_full.show_topics(formatted=False)\r\nflatten_full = [w for w_list in bow_corpus_full for w in w_list]\r\ncounter_full = Counter(flatten_full)\r\n\r\ntopic_weight_full = []\r\nfor i, topic in topics_full:\r\n for word, weight in topic:\r\n topic_weight_full.append([word, i , weight, counter_full[word]])\r\n\r\ndata_frame_full = pd.DataFrame(topic_weight_full, columns=['word', 'topic_id', 'importance', 'word_count']) \r\n\r\nfig, axes = plt.subplots(3, 3, figsize=(10,6), sharey=True, dpi=160)\r\n\r\nfor i, ax in enumerate(axes.flatten()):\r\n ax.bar(x='word', height=\"word_count\", data=data_frame_full.loc[data_frame_full.topic_id==i, :], color=colors[i], width=0.5, alpha=0.3, label='Word Count')\r\n ax_twin = ax.twinx()\r\n ax_twin.bar(x='word', height=\"importance\", data=data_frame_full.loc[data_frame_full.topic_id==i, :], color=colors[i], width=0.2, label='Weights')\r\n ax.set_ylabel('Word Count', color=colors[i])\r\n ax_twin.set_ylim(0, 0.5); ax.set_ylim(0, 100)\r\n ax.set_title('Topic: ' + str(i+1), color=colors[i], fontsize=8)\r\n ax.tick_params(axis='y', left=False)\r\n ax.set_xticklabels(data_frame_full.loc[data_frame_full.topic_id==i, 'word'], rotation=90, horizontalalignment= 'center')\r\n ax.legend(loc='upper left'); ax_twin.legend(loc='upper right')\r\n\r\nfig.tight_layout(w_pad=2) \r\nplt.show()\r\n\r\n\"\"\"\r\n#Word Count & Keyword for Positive Corpus\r\ntopics_pos = lda_pos.show_topics(formatted=False)\r\nflatten_pos = [w for w_list in bow_corpus_pos for w in w_list]\r\ncounter_pos = Counter(flatten_pos)\r\n\r\ntopic_weight_pos = []\r\nfor i, topic in topics_pos:\r\n for word, weight in topic:\r\n topic_weight_pos.append([word, i , weight, counter_pos[word]])\r\n\r\ndata_frame_pos = pd.DataFrame(topic_weight_pos, columns=['word', 'topic_id', 'importance', 'word_count']) \r\n\r\nfig, axes = plt.subplots(3, 3, figsize=(10,6), sharey=True, dpi=160)\r\n\r\nfor i, ax in enumerate(axes.flatten()):\r\n ax.bar(x='word', height=\"word_count\", data=data_frame_pos.loc[data_frame_pos.topic_id==i, :], color=colors[i], width=0.5, alpha=0.3, label='Word Count')\r\n ax_twin = ax.twinx()\r\n ax_twin.bar(x='word', height=\"importance\", data=data_frame_pos.loc[data_frame_pos.topic_id==i, :], color=colors[i], width=0.2, label='Weights')\r\n ax.set_ylabel('Word Count', color=colors[i])\r\n ax_twin.set_ylim(0, 0.5); ax.set_ylim(0, 100)\r\n ax.set_title('Topic: ' + str(i+1), color=colors[i], fontsize=8)\r\n ax.tick_params(axis='y', left=False)\r\n ax.set_xticklabels(data_frame_pos.loc[data_frame_pos.topic_id==i, 'word'], rotation=90, horizontalalignment= 'center')\r\n ax.legend(loc='upper left'); ax_twin.legend(loc='upper right')\r\n\r\nfig.tight_layout(w_pad=2) \r\nplt.show()\r\n\r\n#Word Count & Keyword for Negative Corpus\r\ntopics_neg = lda_neg.show_topics(formatted=False)\r\nflatten_neg = [w for w_list in bow_corpus_neg for w in w_list]\r\ncounter_neg = Counter(flatten_neg)\r\n\r\ntopic_weight_neg = []\r\nfor i, topic in topics_neg:\r\n for word, weight in topic:\r\n topic_weight_neg.append([word, i , weight, counter_neg[word]])\r\n\r\ndata_frame_neg = pd.DataFrame(topic_weight_neg, columns=['word', 'topic_id', 'importance', 'word_count']) \r\n\r\nfig, axes = plt.subplots(3, 3, figsize=(10,6), sharey=True, dpi=160)\r\n\r\nfor i, ax in enumerate(axes.flatten()):\r\n ax.bar(x='word', height=\"word_count\", data=data_frame_neg.loc[data_frame_neg.topic_id==i, :], color=colors[i], width=0.5, alpha=0.3, label='Word Count')\r\n ax_twin = ax.twinx()\r\n ax_twin.bar(x='word', height=\"importance\", data=data_frame_neg.loc[data_frame_neg.topic_id==i, :], color=colors[i], width=0.2, label='Weights')\r\n ax.set_ylabel('Word Count', color=colors[i])\r\n ax_twin.set_ylim(0, 0.5); ax.set_ylim(0, 100)\r\n ax.set_title('Topic: ' + str(i+1), color=colors[i], fontsize=8)\r\n ax.tick_params(axis='y', left=False)\r\n ax.set_xticklabels(data_frame_neg.loc[data_frame_neg.topic_id==i, 'word'], rotation=90, horizontalalignment= 'center')\r\n ax.legend(loc='upper left'); ax_twin.legend(loc='upper right')\r\n\r\nfig.tight_layout(w_pad=2) \r\nplt.show()\r\n\"\"\"\r\n\r\nfrom wordcloud import WordCloud\r\nimport matplotlib.colors as mcolors\r\n#Word Cloud Display for Full Corpus\r\ncloud = WordCloud(stopwords=stoplist, background_color='white', width=2500, height=1800, max_words=7, colormap='tab10', color_func=lambda *args, **kwargs: colors[i], prefer_horizontal=1.0)\r\n\r\ntopics_full = lda_full.show_topics(formatted=False)\r\n\r\nfig, axes = plt.subplots(3, 3, figsize=(10, 6))\r\n\r\nfor i, ax in enumerate(axes.flatten()):\r\n fig.add_subplot(ax)\r\n topic_words_full = dict(topics_full[i][1])\r\n cloud.generate_from_frequencies(topic_words_full, max_font_size=300)\r\n plt.gca().imshow(cloud)\r\n plt.gca().set_title('Topic ' + str(i+1), fontdict=dict(size=10))\r\n plt.gca().axis('off')\r\n\r\nplt.axis('off')\r\nplt.tight_layout()\r\nplt.show()\r\n\r\n\"\"\"\r\n#Word Cloud Display for Positive Corpus\r\ncloud = WordCloud(stopwords=stoplist, background_color='white', width=2500, height=1800, max_words=7, colormap='tab10', color_func=lambda *args, **kwargs: colors[i], prefer_horizontal=1.0)\r\n\r\ntopics_pos = lda_pos.show_topics(formatted=False)\r\n\r\nfig, axes = plt.subplots(3, 3, figsize=(10, 6))\r\n\r\nfor i, ax in enumerate(axes.flatten()):\r\n fig.add_subplot(ax)\r\n topic_words_pos = dict(topics_pos[i][1])\r\n cloud.generate_from_frequencies(topic_words_pos, max_font_size=300)\r\n plt.gca().imshow(cloud)\r\n plt.gca().set_title('Topic ' + str(i+1), fontdict=dict(size=10))\r\n plt.gca().axis('off')\r\n\r\nplt.axis('off')\r\nplt.tight_layout()\r\nplt.show()\r\n\r\n#Word Cloud Display for Negative Corpus\r\ncloud = WordCloud(stopwords=stoplist, background_color='white', width=2500, height=1800, max_words=7, colormap='tab10', color_func=lambda *args, **kwargs: colors[i], prefer_horizontal=1.0)\r\n\r\ntopics_neg = lda_neg.show_topics(formatted=False)\r\n\r\nfig, axes = plt.subplots(3, 3, figsize=(10, 6))\r\n\r\nfor i, ax in enumerate(axes.flatten()):\r\n fig.add_subplot(ax)\r\n topic_words_neg = dict(topics_neg[i][1])\r\n cloud.generate_from_frequencies(topic_words_neg, max_font_size=300)\r\n plt.gca().imshow(cloud)\r\n plt.gca().set_title('Topic ' + str(i+1), fontdict=dict(size=10))\r\n plt.gca().axis('off')\r\n\r\nplt.axis('off')\r\nplt.tight_layout()\r\nplt.show()\r\n\"\"\"\r\n\r\nimport pyLDAvis.gensim\r\nimport pyLDAvis\r\nimport gensim \r\n\r\n#LDA Mallet pyLDAvis for Full Corpus\r\nmallet2lda_full = gensim.models.wrappers.ldamallet.malletmodel2ldamodel(lda_full)\r\nvisualizeLDA_full = pyLDAvis.gensim.prepare(mallet2lda_full, bow_corpus_full, dictionary_full)\r\npyLDAvis.show()\r\n\r\n\"\"\"\r\n#LDA Mallet pyLDAvis for Postiive Corpus\r\nmallet2lda_pos = gensim.models.wrappers.ldamallet.malletmodel2ldamodel(lda_pos)\r\nvisualizeLDA_pos = pyLDAvis.gensim.prepare(mallet2lda_pos, bow_corpus_pos, dictionary_pos)\r\npyLDAvis.show(visualizeLDA_pos)\r\n\r\n#LDA Mallet pyLDAvis for Negative Corpus\r\nmallet2lda_neg = gensim.models.wrappers.ldamallet.malletmodel2ldamodel(lda_neg)\r\nvisualizeLDA_neg = pyLDAvis.gensim.prepare(mallet2lda_neg, bow_corpus_neg, dictionary_neg)\r\npyLDAvis.show(visualizeLDA_neg)\r\n\"\"\"",
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Thu Nov 5 22:53:44 2020\r\n\r\n@author: Emmett\r\n\"\"\"\r\nimport tensorflow as tf\r\nimport os\r\nfrom tensorflow.python.keras.layers import Layer\r\nfrom tensorflow.python.keras import backend as K\r\n\r\n\r\nclass AttentionLayer(Layer):\r\n \"\"\"\r\n This class implements Bahdanau attention (https://arxiv.org/pdf/1409.0473.pdf).\r\n There are three sets of weights introduced W_a, U_a, and V_a\r\n \"\"\"\r\n\r\n def __init__(self, **kwargs):\r\n super(AttentionLayer, self).__init__(**kwargs)\r\n\r\n def build(self, input_shape):\r\n assert isinstance(input_shape, list)\r\n # Create a trainable weight variable for this layer.\r\n\r\n self.W_a = self.add_weight(name='W_a',\r\n shape=tf.TensorShape((input_shape[0][2], input_shape[0][2])),\r\n initializer='uniform',\r\n trainable=True)\r\n self.U_a = self.add_weight(name='U_a',\r\n shape=tf.TensorShape((input_shape[1][2], input_shape[0][2])),\r\n initializer='uniform',\r\n trainable=True)\r\n self.V_a = self.add_weight(name='V_a',\r\n shape=tf.TensorShape((input_shape[0][2], 1)),\r\n initializer='uniform',\r\n trainable=True)\r\n\r\n super(AttentionLayer, self).build(input_shape) # Be sure to call this at the end\r\n\r\n def call(self, inputs, verbose=False):\r\n \"\"\"\r\n inputs: [encoder_output_sequence, decoder_output_sequence]\r\n \"\"\"\r\n assert type(inputs) == list\r\n encoder_out_seq, decoder_out_seq = inputs\r\n if verbose:\r\n print('encoder_out_seq>', encoder_out_seq.shape)\r\n print('decoder_out_seq>', decoder_out_seq.shape)\r\n\r\n def energy_step(inputs, states):\r\n \"\"\" Step function for computing energy for a single decoder state\r\n inputs: (batchsize * 1 * de_in_dim)\r\n states: (batchsize * 1 * de_latent_dim)\r\n \"\"\"\r\n\r\n assert_msg = \"States must be an iterable. Got {} of type {}\".format(states, type(states))\r\n assert isinstance(states, list) or isinstance(states, tuple), assert_msg\r\n\r\n \"\"\" Some parameters required for shaping tensors\"\"\"\r\n en_seq_len, en_hidden = encoder_out_seq.shape[1], encoder_out_seq.shape[2]\r\n de_hidden = inputs.shape[-1]\r\n\r\n \"\"\" Computing S.Wa where S=[s0, s1, ..., si]\"\"\"\r\n # <= batch size * en_seq_len * latent_dim\r\n W_a_dot_s = K.dot(encoder_out_seq, self.W_a)\r\n\r\n \"\"\" Computing hj.Ua \"\"\"\r\n U_a_dot_h = K.expand_dims(K.dot(inputs, self.U_a), 1) # <= batch_size, 1, latent_dim\r\n if verbose:\r\n print('Ua.h>', U_a_dot_h.shape)\r\n\r\n \"\"\" tanh(S.Wa + hj.Ua) \"\"\"\r\n # <= batch_size*en_seq_len, latent_dim\r\n Ws_plus_Uh = K.tanh(W_a_dot_s + U_a_dot_h)\r\n if verbose:\r\n print('Ws+Uh>', Ws_plus_Uh.shape)\r\n\r\n \"\"\" softmax(va.tanh(S.Wa + hj.Ua)) \"\"\"\r\n # <= batch_size, en_seq_len\r\n e_i = K.squeeze(K.dot(Ws_plus_Uh, self.V_a), axis=-1)\r\n # <= batch_size, en_seq_len\r\n e_i = K.softmax(e_i)\r\n\r\n if verbose:\r\n print('ei>', e_i.shape)\r\n\r\n return e_i, [e_i]\r\n\r\n def context_step(inputs, states):\r\n \"\"\" Step function for computing ci using ei \"\"\"\r\n\r\n assert_msg = \"States must be an iterable. Got {} of type {}\".format(states, type(states))\r\n assert isinstance(states, list) or isinstance(states, tuple), assert_msg\r\n\r\n # <= batch_size, hidden_size\r\n c_i = K.sum(encoder_out_seq * K.expand_dims(inputs, -1), axis=1)\r\n if verbose:\r\n print('ci>', c_i.shape)\r\n return c_i, [c_i]\r\n\r\n fake_state_c = K.sum(encoder_out_seq, axis=1)\r\n fake_state_e = K.sum(encoder_out_seq, axis=2) # <= (batch_size, enc_seq_len, latent_dim\r\n\r\n \"\"\" Computing energy outputs \"\"\"\r\n # e_outputs => (batch_size, de_seq_len, en_seq_len)\r\n last_out, e_outputs, _ = K.rnn(\r\n energy_step, decoder_out_seq, [fake_state_e],\r\n )\r\n\r\n \"\"\" Computing context vectors \"\"\"\r\n last_out, c_outputs, _ = K.rnn(\r\n context_step, e_outputs, [fake_state_c],\r\n )\r\n\r\n return c_outputs, e_outputs\r\n\r\n def compute_output_shape(self, input_shape):\r\n \"\"\" Outputs produced by the layer \"\"\"\r\n return [\r\n tf.TensorShape((input_shape[1][0], input_shape[1][1], input_shape[1][2])),\r\n tf.TensorShape((input_shape[1][0], input_shape[1][1], input_shape[0][1]))\r\n ]"
] | [
[
"numpy.zeros",
"pandas.DataFrame",
"matplotlib.pyplot.title",
"sklearn.manifold.TSNE",
"matplotlib.pyplot.subplots",
"numpy.argmax",
"matplotlib.pyplot.show",
"matplotlib.pyplot.tight_layout",
"matplotlib.colors.TABLEAU_COLORS.items",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.axis"
],
[
"tensorflow.TensorShape",
"tensorflow.python.keras.backend.softmax",
"tensorflow.python.keras.backend.expand_dims",
"tensorflow.python.keras.backend.sum",
"tensorflow.python.keras.backend.tanh",
"tensorflow.python.keras.backend.rnn",
"tensorflow.python.keras.backend.dot"
]
] |
LatencyTDH/DeepSpeed | [
"eecef309cb12528cfa78d932a6f073afb43847e5"
] | [
"deepspeed/runtime/engine.py"
] | [
"'''\nCopyright 2019 The Microsoft DeepSpeed Team\n'''\n\nimport os\nimport stat\nimport torch\nimport warnings\nimport hashlib\nimport torch.distributed as dist\nfrom collections import OrderedDict\nfrom shutil import copyfile\n\nfrom torch.nn.modules import Module\nfrom torch.distributed.distributed_c10d import _get_global_rank\nfrom tensorboardX import SummaryWriter\n\nfrom deepspeed.runtime.utils import see_memory_usage\nfrom deepspeed.runtime.zero.stage2 import FP16_DeepSpeedZeroOptimizer\nfrom deepspeed.runtime.zero.stage1 import FP16_DeepSpeedZeroOptimizer_Stage1\nfrom deepspeed.runtime.zero.partition_parameters import ZeroParamStatus\nfrom deepspeed.runtime.zero.utils import is_zero_supported_optimizer\nfrom deepspeed.runtime.activation_checkpointing import checkpointing as activation_checkpointing\nfrom deepspeed.runtime.fp16.fused_optimizer import FP16_Optimizer\nfrom deepspeed.runtime.fp16.unfused_optimizer import FP16_UnfusedOptimizer\nfrom deepspeed.runtime.config import DeepSpeedConfig, DEEPSPEED_OPTIMIZERS, \\\n ADAM_OPTIMIZER, ADAMW_OPTIMIZER, LAMB_OPTIMIZER, ONEBIT_ADAM_OPTIMIZER, \\\n TORCH_ADAM_PARAM, ADAM_W_MODE, ADAM_W_MODE_DEFAULT\n\nfrom deepspeed.runtime.dataloader import DeepSpeedDataLoader\nfrom deepspeed.runtime.constants import \\\n ROUTE_TRAIN, ROUTE_PREDICT, ROUTE_EVAL, \\\n PLD_THETA, PLD_GAMMA\nfrom deepspeed.runtime.zero.constants import \\\n ZERO_OPTIMIZATION_OPTIMIZER_STATES, ZERO_OPTIMIZATION_GRADIENTS, ZERO_OPTIMIZATION_WEIGHTS\nfrom deepspeed.runtime.csr_tensor import CSRTensor\nimport deepspeed.runtime.lr_schedules as lr_schedules\nfrom deepspeed.utils import logger, log_dist, init_distributed\nfrom deepspeed.utils.timer import ThroughputTimer, SynchronizedWallClockTimer\nfrom deepspeed.runtime.progressive_layer_drop import ProgressiveLayerDrop\n\nfrom .pipe.module import PipelineModule\nfrom .utils import ensure_directory_exists\nfrom ..ops.op_builder import UtilsBuilder\nfrom ..ops.adam import DeepSpeedCPUAdam\nfrom ..ops.adam import FusedAdam\n\nfrom deepspeed.profiling.flops_profiler.profiler import FlopsProfiler\n\nMEMORY_OPT_ALLREDUCE_SIZE = 500000000\n\ntry:\n from apex import amp\nexcept ImportError:\n # Fail silently so we don't spam logs unnecessarily if user isn't using amp\n pass\n\n\ndef split_half_float_double_csr(tensors):\n dtypes = [\n \"torch.cuda.HalfTensor\",\n \"torch.cuda.FloatTensor\",\n \"torch.cuda.DoubleTensor\",\n CSRTensor.type()\n ]\n buckets = []\n for i, dtype in enumerate(dtypes):\n bucket = [t for t in tensors if t.type() == dtype]\n if bucket:\n buckets.append((dtype, bucket))\n return buckets\n\n\ndef _initialize_parameter_parallel_groups(parameter_parallel_size=None):\n data_parallel_size = int(dist.get_world_size())\n if parameter_parallel_size is None:\n parameter_parallel_size = int(data_parallel_size)\n logger.info(\"data_parallel_size: %s, parameter_parallel_size: %s\",\n data_parallel_size,\n parameter_parallel_size)\n assert data_parallel_size % parameter_parallel_size == 0, \\\n 'world size should be divisible by parameter parallel size'\n rank = dist.get_rank()\n my_group = None\n for i in range(dist.get_world_size() // parameter_parallel_size):\n ranks = range(i * parameter_parallel_size, (i + 1) * parameter_parallel_size)\n group = torch.distributed.new_group(ranks)\n if rank in ranks:\n my_group = group\n return my_group\n\n\ndef print_configuration(args, name):\n logger.info('{}:'.format(name))\n for arg in sorted(vars(args)):\n dots = '.' * (29 - len(arg))\n logger.info(' {} {} {}'.format(arg, dots, getattr(args, arg)))\n\n\nclass DeepSpeedEngine(Module):\n r\"\"\"DeepSpeed engine for training.\n \"\"\"\n def __init__(self,\n args,\n model,\n optimizer=None,\n model_parameters=None,\n training_data=None,\n lr_scheduler=None,\n mpu=None,\n dist_init_required=None,\n collate_fn=None,\n config_params=None,\n dont_change_device=False):\n super(DeepSpeedEngine, self).__init__()\n self.dont_change_device = dont_change_device\n self.client_optimizer = optimizer\n self.client_model_parameters = model_parameters\n self.client_lr_scheduler = lr_scheduler\n self.training_data = training_data\n self.collate_fn = collate_fn\n self.mpu = mpu\n self.data_parallel_group = None\n self.global_steps = 0\n self.global_samples = 0\n self.micro_steps = 0\n self.skipped_steps = 0\n self.gradient_average = True\n self.warn_unscaled_loss = True\n self.config_params = config_params\n self.loaded_checkpoint_mp_world_size = None\n self.loaded_checkpoint_dp_world_size = None\n self.enable_backward_allreduce = True\n self.progressive_layer_drop = None\n self.dist_backend = \"nccl\"\n\n if dist_init_required is None:\n dist_init_required = not dist.is_initialized()\n\n if dist_init_required is False:\n assert dist.is_initialized() is True, \"Torch distributed not initialized. Please set dist_init_required to True or initialize before calling deepspeed.initialize()\"\n else:\n # Initialize torch distributed if needed\n init_distributed(dist_backend=self.dist_backend)\n\n see_memory_usage(f\"DeepSpeed Engine: Before args sanity test\")\n self._do_args_sanity_check(args)\n self._configure_with_arguments(args, mpu)\n self._do_sanity_check()\n\n if mpu is not None:\n assert not self.elasticity_enabled(), \"Elasticity is not currently supported\" \\\n \" with model parallelism.\"\n\n self._set_distributed_vars()\n\n if self.tensorboard_enabled() and self.global_rank == 0:\n self.summary_writer = self.get_summary_writer()\n\n see_memory_usage(f\"DeepSpeed Engine: Before configure distributed model\")\n\n # Configure distributed model\n self._configure_distributed_model(model)\n\n see_memory_usage(f\"DeepSpeed Engine: After configure distributed model\")\n\n # Configure wall clock timer\n self.timers = SynchronizedWallClockTimer()\n\n # Throughput timer\n self.tput_timer = ThroughputTimer(\n batch_size=self.train_micro_batch_size_per_gpu(),\n num_workers=self.dp_world_size,\n steps_per_output=self.steps_per_print(),\n monitor_memory=False)\n\n if training_data:\n self.training_dataloader = self.deepspeed_io(training_data)\n else:\n self.training_dataloader = None\n\n # Configure optimizer and scheduler\n self.optimizer = None\n self.lr_scheduler = None\n if model_parameters or optimizer:\n self._configure_optimizer(optimizer, model_parameters)\n self._configure_lr_scheduler(lr_scheduler)\n self._report_progress(0)\n\n # Bookkeeping for csr support\n self.csr_tensor_module_names = set()\n if self.sparse_gradients_enabled():\n for name, module in self.module.named_modules():\n if isinstance(module, torch.nn.Embedding):\n self.csr_tensor_module_names.add(name + \".weight\")\n logger.info(\"Will convert {} to sparse (csr) \"\n \"tensor during training\".format(name))\n\n self.save_non_zero_checkpoint = False\n self.save_zero_checkpoint = False\n self._configure_checkpointing(dist_init_required)\n\n if self.pld_enabled():\n self.progressive_layer_drop = self._configure_progressive_layer_drop()\n\n if self.global_rank == 0:\n self._config.print('DeepSpeedEngine configuration')\n if self.dump_state():\n print_configuration(self, 'DeepSpeedEngine')\n\n # Load pre-installed or JIT compile (un)flatten ops\n util_ops = UtilsBuilder().load()\n self.flatten = util_ops.flatten\n self.unflatten = util_ops.unflatten\n\n def get_batch_info(self):\n \"\"\" Get all training batch related settings.\n\n Returns:\n train_batch_size (int): The effective training batch size. This is the amount of data\n samples that leads to one step of model update.\n train_micro_batch_size_per_gpu (int): Batch size to be processed by one GPU in one\n step (without gradient accumulation).\n gradient_accumulation_steps (int): Number of training steps to accumulate gradients\n before averaging and applying them.\n \"\"\"\n return self.train_batch_size, self.train_micro_batch_size_per_gpu, self.gradient_accumulation_steps\n\n def checkpoint_tag_validation_enabled(self):\n return self._config.checkpoint_tag_validation_enabled\n\n def checkpoint_tag_validation_fail(self):\n return self._config.checkpoint_tag_validation_fail\n\n def elasticity_enabled(self):\n return self._config.elasticity_enabled\n\n def pld_enabled(self):\n return self._config.pld_enabled\n\n def pld_params(self):\n return self._config.pld_params\n\n def pld_theta(self):\n return self.pld_params()[PLD_THETA]\n\n def pld_gamma(self):\n return self.pld_params()[PLD_GAMMA]\n\n def tensorboard_enabled(self):\n return self._config.tensorboard_enabled\n\n def tensorboard_output_path(self):\n return self._config.tensorboard_output_path\n\n def tensorboard_job_name(self):\n return self._config.tensorboard_job_name\n\n def get_summary_writer(self,\n name=\"DeepSpeedJobName\",\n base=os.path.join(os.path.expanduser(\"~\"),\n \"tensorboard\")):\n if self.tensorboard_output_path():\n base_dir = self.tensorboard_output_path()\n job_name = self.tensorboard_job_name()\n log_dir = os.path.join(base_dir, job_name)\n else:\n if self.tensorboard_job_name():\n name = self.tensorboard_job_name()\n\n # Infrastructure-specific job-id\n if 'DLWS_JOB_ID' in os.environ:\n infra_job_id = os.environ['DLWS_JOB_ID']\n elif 'DLTS_JOB_ID' in os.environ:\n infra_job_id = os.environ['DLTS_JOB_ID']\n else:\n infra_job_id = 'unknown-job-id'\n\n summary_writer_dir_name = os.path.join(infra_job_id, \"logs\")\n log_dir = os.path.join(base, summary_writer_dir_name, name)\n\n os.makedirs(log_dir, exist_ok=True)\n\n return SummaryWriter(log_dir=log_dir)\n\n def wall_clock_breakdown(self):\n return self._config.wall_clock_breakdown\n\n def flops_profiler_enabled(self):\n return self._config.flops_profiler_config.enabled\n\n def flops_profiler_profile_step(self):\n return self._config.flops_profiler_config.profile_step\n\n def flops_profiler_module_depth(self):\n return self._config.flops_profiler_config.module_depth\n\n def flops_profiler_top_modules(self):\n return self._config.flops_profiler_config.top_modules\n\n def flops_profiler_detailed(self):\n return self._config.flops_profiler_config.detailed\n\n def memory_breakdown(self):\n return self._config.memory_breakdown\n\n def sparse_gradients_enabled(self):\n return self._config.sparse_gradients_enabled\n\n def train_batch_size(self):\n return self._config.train_batch_size\n\n def train_micro_batch_size_per_gpu(self):\n return self._config.train_micro_batch_size_per_gpu\n\n def optimizer_name(self):\n return self.client_optimizer.__class__.__name__ if self.client_optimizer else self._config.optimizer_name\n\n def optimizer_params(self):\n return self._config.optimizer_params\n\n def optimizer_legacy_fusion(self):\n return self._config.optimizer_legacy_fusion\n\n def scheduler_name(self):\n return self._config.scheduler_name\n\n def scheduler_params(self):\n return self._config.scheduler_params\n\n def zero_optimization(self):\n return self._config.zero_enabled\n\n def zero_allow_untested_optimizer(self):\n return self._config.zero_allow_untested_optimizer\n\n def zero_reduce_scatter(self):\n return self._config.zero_config.reduce_scatter\n\n def zero_overlap_comm(self):\n return self._config.zero_config.overlap_comm\n\n def zero_offload_optimizer(self):\n return self._config.zero_config.offload_optimizer\n\n def zero_offload_param(self):\n return self._config.zero_config.offload_param\n\n def zero_cpu_offload(self):\n return self._config.zero_config.offload_optimizer is not None\n\n def zero_sub_group_size(self):\n return self._config.zero_config.sub_group_size\n\n def zero_optimization_stage(self):\n return self._config.zero_optimization_stage\n\n def zero_reduce_bucket_size(self):\n return self._config.zero_config.reduce_bucket_size\n\n def zero_allgather_bucket_size(self):\n return self._config.zero_config.allgather_bucket_size\n\n def zero_optimization_partition_gradients(self):\n return self.zero_optimization_stage() >= ZERO_OPTIMIZATION_GRADIENTS\n\n def zero_optimization_partition_weights(self):\n return self.zero_optimization_stage() >= ZERO_OPTIMIZATION_WEIGHTS\n\n def zero_contiguous_gradients(self):\n return self._config.zero_config.contiguous_gradients\n\n def zero_load_from_fp32_weights(self):\n return self._config.zero_config.load_from_fp32_weights\n\n def zero_elastic_checkpoint(self):\n return self._config.zero_config.elastic_checkpoint\n\n def zero_max_live_parameters(self):\n return self._config.zero_config.max_live_parameters\n\n def zero_max_reuse_distance(self):\n return self._config.zero_config.max_reuse_distance\n\n def zero_prefetch_bucket_size(self):\n return self._config.zero_config.prefetch_bucket_size\n\n def zero_param_persistence_threshold(self):\n return self._config.zero_config.param_persistence_threshold\n\n def zero_gather_fp16_weights_on_model_save(self):\n return self._config.zero_config.gather_fp16_weights_on_model_save\n\n def fp16_enabled(self):\n return self._config.fp16_enabled\n\n def amp_enabled(self):\n return self._config.amp_enabled\n\n def amp_params(self):\n return self._config.amp_params\n\n def loss_scale(self):\n return self._config.loss_scale\n\n def gradient_accumulation_steps(self):\n return self._config.gradient_accumulation_steps\n\n def allreduce_always_fp32(self):\n return self._config.allreduce_always_fp32\n\n def postscale_gradients(self):\n return not self._config.prescale_gradients\n\n def gradient_predivide_factor(self):\n return self._config.gradient_predivide_factor\n\n def steps_per_print(self):\n return self._config.steps_per_print\n\n def zero_allgather_partitions(self):\n return self._config.zero_config.allgather_partitions\n\n def dump_state(self):\n return self._config.dump_state\n\n def gradient_clipping(self):\n return self._config.gradient_clipping\n\n def dynamic_loss_scale(self):\n return self._config.loss_scale == 0\n\n def initial_dynamic_scale(self):\n return self._config.initial_dynamic_scale\n\n def dynamic_loss_scale_args(self):\n return self._config.dynamic_loss_scale_args\n\n def swap_tensor_config(self):\n return self._config.swap_tensor_config\n\n def aio_config(self):\n return self._config.aio_config\n\n def _configure_lr_scheduler(self, client_lr_scheduler):\n # First check for scheduler in json configuration\n lr_scheduler = self._scheduler_from_config(self.optimizer)\n if lr_scheduler:\n if self.global_rank == 0:\n logger.info(\n f'DeepSpeed using configured LR scheduler = {self.scheduler_name()}')\n self.lr_scheduler = lr_scheduler\n else:\n if self.global_rank == 0:\n logger.info('DeepSpeed using client LR scheduler')\n self.lr_scheduler = client_lr_scheduler\n log_dist(f'DeepSpeed LR Scheduler = {self.lr_scheduler}', ranks=[0])\n\n def _configure_checkpointing(self, dist_init_required):\n\n dp_rank = self.global_rank\n if self.mpu:\n dp_rank = self.mpu.get_data_parallel_rank()\n\n # only the first data parallel process needs to store the model checkpoint\n self.save_non_zero_checkpoint = (\n dp_rank == 0) or self.zero_optimization_partition_weights()\n\n if self.zero_optimization():\n param_rank = torch.distributed.get_rank(\n group=self.optimizer.dp_process_group)\n\n # Only the first parameter parallel process needs to store the\n # optimizer state checkpoints for zero\n self.save_zero_checkpoint = (param_rank == dp_rank)\n\n def _scheduler_from_config(self, optimizer):\n scheduler_name = self.scheduler_name()\n if scheduler_name is not None:\n if hasattr(lr_schedules, scheduler_name):\n scheduler = getattr(lr_schedules, scheduler_name)\n else:\n assert hasattr(torch.optim.lr_scheduler, scheduler_name), \\\n f\"DeepSpeed does not recognize LR scheduler {scheduler_name}\"\n\n scheduler = getattr(torch.optim.lr_scheduler, scheduler_name)\n\n scheduler_params = self.scheduler_params()\n instantiated_scheduler = scheduler(optimizer, **scheduler_params)\n return instantiated_scheduler\n else:\n return None\n\n def _set_distributed_vars(self):\n if self.local_rank >= 0:\n torch.cuda.set_device(self.local_rank)\n self.device = torch.device(\"cuda\", self.local_rank)\n self.world_size = dist.get_world_size()\n self.global_rank = dist.get_rank()\n else:\n self.world_size = 1\n self.global_rank = 0\n self.device = torch.device(\"cuda\")\n\n # Configure based on command line arguments\n def _configure_with_arguments(self, args, mpu):\n # After the distributed backend is initialized we are guaranteed the LOCAL_RANK\n # environment variable is set. We must align args.local_rank to this value for\n # backwards compatability with scripts relying on [args|self].local_rank containing\n # the correct local rank info. _do_args_sanity_check will ensure this is the case.\n self.local_rank = int(os.environ['LOCAL_RANK'])\n if hasattr(args, 'local_rank'):\n args.local_rank = self.local_rank\n\n config_file = args.deepspeed_config if hasattr(args,\n 'deepspeed_config') else None\n self._config = DeepSpeedConfig(config_file, mpu, param_dict=self.config_params)\n\n # Validate command line arguments\n def _do_args_sanity_check(self, args):\n if hasattr(args, 'deepscale_config') and args.deepscale_config is not None:\n logger.warning(\n \"************ --deepscale_config is deprecated, please use --deepspeed_config ************\"\n )\n if hasattr(args, 'deepspeed_config'):\n assert args.deepspeed_config is None, \"Not sure how to proceed, we were given both a deepscale_config and deepspeed_config\"\n args.deepspeed_config = args.deepscale_config\n\n assert \"LOCAL_RANK\" in os.environ, \"DeepSpeed requires the LOCAL_RANK environment variable, it is set by the deepspeed launcher, \" \\\n \"deepspeed.init_distributed, or the torch.distributed launcher. If using a different launcher please ensure LOCAL_RANK is set prior to initializing deepspeed.\"\n if hasattr(args, 'local_rank') and args.local_rank != None:\n assert isinstance(args.local_rank, int), f\"args.local_rank of {args.local_rank} is an unknown type {type(args.local_rank)}\"\n if args.local_rank >= 0:\n env_local_rank = int(os.environ.get(\"LOCAL_RANK\"))\n assert env_local_rank == args.local_rank, \\\n f\"Mismatch in local rank setting, args.local_rank={args.local_rank} but env['LOCAL_RANK']={env_local_rank}.\"\n\n if self.config_params is None:\n assert hasattr(args, 'deepspeed_config') and args.deepspeed_config is not None, \\\n 'DeepSpeed requires --deepspeed_config to specify configuration file'\n\n assert os.path.isfile(args.deepspeed_config), \\\n 'DeepSpeed configuration file: {} is not an existing file'.format(args.deepspeed_config)\n\n def _is_supported_optimizer(self, optimizer_name):\n return optimizer_name in DEEPSPEED_OPTIMIZERS or \\\n getattr(torch.optim, optimizer_name, None) is not None\n\n # Validate configuration based on command line arguments\n def _do_sanity_check(self):\n if not self.client_optimizer:\n if self.optimizer_name() is not None:\n assert self._is_supported_optimizer(self.optimizer_name()), \\\n '{} is not a supported DeepSpeed Optimizer'.format(self.optimizer_name())\n\n if self.optimizer_name() == LAMB_OPTIMIZER:\n assert self.dynamic_loss_scale(), \\\n 'DeepSpeed {} optimizer requires dynamic loss scaling'.format(self.optimizer_name())\n\n def _broadcast_model(self):\n def is_replicated(p):\n if hasattr(p, 'ds_status') and p.ds_status is not ZeroParamStatus.AVAILABLE:\n return False\n return True\n\n for p in self.module.parameters():\n if torch.is_tensor(p) and is_replicated(p):\n dist.broadcast(p,\n self.broadcast_src_rank,\n group=self.data_parallel_group)\n\n def _configure_distributed_model(self, model):\n self.module = model\n if self.fp16_enabled():\n self.module.half()\n\n if not self.dont_change_device:\n self.module.to(self.device)\n\n if self.mpu is None:\n self.data_parallel_group = _initialize_parameter_parallel_groups()\n self.dp_world_size = dist.get_world_size()\n self.mp_world_size = 1\n self.broadcast_src_rank = 0\n else:\n self.data_parallel_group = self.mpu.get_data_parallel_group()\n self.dp_world_size = self.mpu.get_data_parallel_world_size()\n self.mp_world_size = self.mpu.get_model_parallel_world_size()\n self.broadcast_src_rank = _get_global_rank(\n self.mpu.get_data_parallel_group(),\n 0)\n\n if not self.amp_enabled():\n self._broadcast_model()\n\n # Configure optimizer\n def _configure_optimizer(self, client_optimizer, model_parameters):\n\n if client_optimizer is not None:\n client_optimizer.param_groups[:] = [\n pg for pg in client_optimizer.param_groups if len(pg[\"params\"]) != 0\n ]\n if self.global_rank == 0:\n logger.info(\n \"Removing param_group that has no 'params' in the client Optimizer\")\n\n basic_optimizer = client_optimizer\n if self.global_rank == 0:\n logger.info('Using client Optimizer as basic optimizer')\n else:\n basic_optimizer = self._configure_basic_optimizer(model_parameters)\n if self.global_rank == 0:\n logger.info(\n 'Using DeepSpeed Optimizer param name {} as basic optimizer'.format(\n self.optimizer_name()))\n\n if self.global_rank == 0:\n logger.info('DeepSpeed Basic Optimizer = {}'.format(\n basic_optimizer.__class__.__name__))\n\n if self.zero_optimization():\n assert not self.amp_enabled(), \"Amp and ZeRO are not currently compatible, please use (legacy) fp16 mode which performs similar to amp opt_mode=O2\"\n if not is_zero_supported_optimizer(basic_optimizer):\n assert self.zero_allow_untested_optimizer(), \\\n 'You are using an untested ZeRO Optimizer. Please add <\"zero_allow_untested_optimizer\": true> in the configuration file to use it.'\n\n if self.global_rank == 0:\n logger.warning(\n \"**** You are using ZeRO with an untested optimizer, proceed with caution *****\"\n )\n self.optimizer = self._configure_zero_optimizer(basic_optimizer)\n elif self.amp_enabled():\n assert not self.fp16_enabled(), \"Cannot enable both amp with (legacy) fp16 mode\"\n amp_params = self.amp_params()\n if self.global_rank == 0:\n logger.info(f\"Initializing AMP with these params: {amp_params}\")\n try:\n logger.info(\"Initializing Apex amp from: {}\".format(amp.__path__))\n except NameError:\n # If apex/amp is available it will be imported above\n raise RuntimeError(\n \"Unable to import apex/amp, please make sure it is installed\")\n self.module, self.optimizer = amp.initialize(self.module, basic_optimizer, **amp_params)\n self._broadcast_model()\n elif self.fp16_enabled():\n self.optimizer = self._configure_fp16_optimizer(basic_optimizer)\n else:\n self.optimizer = basic_optimizer\n log_dist('DeepSpeed Final Optimizer = {}'.format(self.optimizer_name()),\n ranks=[0])\n\n def _configure_basic_optimizer(self, model_parameters):\n optimizer_parameters = self.optimizer_params()\n # print(optimizer_parameters.keys())\n if 'max_grad_norm' in optimizer_parameters.keys():\n raise ValueError(\n \"'max_grad_norm' is not supported as an optimizer parameter, please switch to using the deepspeed parameter 'gradient_clipping' see: https://www.deepspeed.ai/docs/config-json/#gradient-clipping for more details\"\n )\n\n if self.optimizer_name() in [ADAM_OPTIMIZER, ADAMW_OPTIMIZER]:\n torch_adam = optimizer_parameters.pop(TORCH_ADAM_PARAM, False)\n adam_w_mode = optimizer_parameters.pop(ADAM_W_MODE, ADAM_W_MODE_DEFAULT)\n\n # Optimizer name of Adam forces AdamW logic unless adam_w_mode is explictly set\n effective_adam_w_mode = self.optimizer_name(\n ) == ADAMW_OPTIMIZER or adam_w_mode\n\n if torch_adam:\n if not effective_adam_w_mode:\n optimizer = torch.optim.Adam(model_parameters,\n **optimizer_parameters)\n else:\n optimizer = torch.optim.AdamW(model_parameters,\n **optimizer_parameters)\n else:\n if self.zero_cpu_offload():\n from deepspeed.ops.adam import DeepSpeedCPUAdam\n optimizer = DeepSpeedCPUAdam(model_parameters,\n **optimizer_parameters,\n adamw_mode=effective_adam_w_mode)\n else:\n from deepspeed.ops.adam import FusedAdam\n optimizer = FusedAdam(model_parameters,\n **optimizer_parameters,\n adam_w_mode=effective_adam_w_mode)\n\n elif self.optimizer_name() == LAMB_OPTIMIZER:\n from deepspeed.ops.lamb import FusedLamb\n optimizer = FusedLamb(model_parameters, **optimizer_parameters)\n elif self.optimizer_name() == ONEBIT_ADAM_OPTIMIZER:\n from deepspeed.runtime.fp16.onebit.adam import OnebitAdam\n optimizer = OnebitAdam(model_parameters, self, **optimizer_parameters)\n if not self.fp16_enabled():\n logger.warning(\n f'Currently the convergence of 1-bit Adam is only verified under FP16'\n )\n else:\n torch_optimizer = getattr(torch.optim, self.optimizer_name())\n optimizer = torch_optimizer(model_parameters, **optimizer_parameters)\n return optimizer\n\n def _configure_fp16_optimizer(self, optimizer):\n initial_dynamic_scale = self.initial_dynamic_scale()\n dynamic_loss_args = self.dynamic_loss_scale_args()\n clip_grad = self.gradient_clipping()\n if isinstance(optimizer,\n FusedAdam) or self.optimizer_name() == ONEBIT_ADAM_OPTIMIZER:\n if self.dynamic_loss_scale():\n log_dist('Creating fp16 optimizer with dynamic loss scale', ranks=[0])\n timers = self.timers if self.wall_clock_breakdown() else None\n optimizer = FP16_Optimizer(\n optimizer,\n dynamic_loss_scale=True,\n initial_dynamic_scale=initial_dynamic_scale,\n dynamic_loss_args=dynamic_loss_args,\n mpu=self.mpu,\n clip_grad=clip_grad,\n fused_adam_legacy=self.optimizer_legacy_fusion(),\n timers=timers)\n else:\n log_dist('Creating fp16 optimizer with static loss scale: {}'.format(\n self.loss_scale()),\n ranks=[0])\n optimizer = FP16_Optimizer(\n optimizer,\n static_loss_scale=self.loss_scale(),\n mpu=self.mpu,\n clip_grad=clip_grad,\n fused_adam_legacy=self.optimizer_legacy_fusion())\n else:\n log_dist('Creating fp16 unfused optimizer with dynamic loss scale',\n ranks=[0])\n optimizer = FP16_UnfusedOptimizer(\n optimizer,\n static_loss_scale=self.loss_scale(),\n dynamic_loss_scale=self.dynamic_loss_scale(),\n dynamic_loss_args=dynamic_loss_args,\n mpu=self.mpu,\n clip_grad=clip_grad,\n fused_lamb_legacy=self.optimizer_name() == LAMB_OPTIMIZER)\n\n return optimizer\n\n def _configure_zero_optimizer(self, optimizer):\n zero_stage = self.zero_optimization_stage()\n log_dist('Creating fp16 ZeRO stage {} optimizer'.format(zero_stage), ranks=[0])\n assert not self.allreduce_always_fp32(), \"ZeRO does not support 'fp32_allreduce': true\"\n timers = self.timers if self.wall_clock_breakdown() else None\n\n if zero_stage == ZERO_OPTIMIZATION_OPTIMIZER_STATES:\n assert self.zero_reduce_scatter(), 'Stage 1 only supports reduce scatter mode'\n optimizer = FP16_DeepSpeedZeroOptimizer_Stage1(\n optimizer,\n static_loss_scale=self.loss_scale(),\n dynamic_loss_scale=self.dynamic_loss_scale(),\n dynamic_loss_args=self.dynamic_loss_scale_args(),\n clip_grad=self.gradient_clipping(),\n all_gather_partitions=self.zero_allgather_partitions(),\n allgather_size=self.zero_allgather_bucket_size(),\n max_elements_per_comm=self.zero_reduce_bucket_size(),\n dp_process_group=self.data_parallel_group,\n elastic_checkpoint=self.zero_elastic_checkpoint(),\n mpu=self.mpu)\n elif zero_stage == ZERO_OPTIMIZATION_GRADIENTS:\n optimizer = FP16_DeepSpeedZeroOptimizer(\n optimizer,\n timers=timers,\n static_loss_scale=self.loss_scale(),\n dynamic_loss_scale=self.dynamic_loss_scale(),\n dynamic_loss_args=self.dynamic_loss_scale_args(),\n clip_grad=self.gradient_clipping(),\n contiguous_gradients=self.zero_contiguous_gradients(),\n reduce_bucket_size=self.zero_reduce_bucket_size(),\n allgather_bucket_size=self.zero_allgather_bucket_size(),\n dp_process_group=self.data_parallel_group,\n reduce_scatter=self.zero_reduce_scatter(),\n overlap_comm=self.zero_overlap_comm(),\n cpu_offload=self.zero_cpu_offload(),\n mpu=self.mpu,\n postscale_gradients=self.postscale_gradients(),\n gradient_predivide_factor=self.gradient_predivide_factor(),\n gradient_accumulation_steps=self.gradient_accumulation_steps())\n elif zero_stage == ZERO_OPTIMIZATION_WEIGHTS:\n print(\"Initializing ZeRO Stage 3\") if dist.get_rank() == 0 else None\n from deepspeed.runtime.zero.stage3 import FP16_DeepSpeedZeroOptimizer_Stage3\n optimizer = FP16_DeepSpeedZeroOptimizer_Stage3(\n self.module,\n optimizer,\n timers=timers,\n static_loss_scale=self.loss_scale(),\n dynamic_loss_scale=self.dynamic_loss_scale(),\n dynamic_loss_args=self.dynamic_loss_scale_args(),\n clip_grad=self.gradient_clipping(),\n contiguous_gradients=self.zero_contiguous_gradients(),\n reduce_bucket_size=self.zero_reduce_bucket_size(),\n prefetch_bucket_size=self.zero_prefetch_bucket_size(),\n max_reuse_distance=self.zero_max_reuse_distance(),\n max_live_parameters=self.zero_max_live_parameters(),\n param_persistence_threshold=self.zero_param_persistence_threshold(),\n dp_process_group=self.data_parallel_group,\n reduce_scatter=self.zero_reduce_scatter(),\n overlap_comm=self.zero_overlap_comm(),\n offload_optimizer_config=self.zero_offload_optimizer(),\n offload_param_config=self.zero_offload_param(),\n sub_group_size=self.zero_sub_group_size(),\n mpu=self.mpu,\n postscale_gradients=self.postscale_gradients(),\n gradient_predivide_factor=self.gradient_predivide_factor(),\n gradient_accumulation_steps=self.gradient_accumulation_steps(),\n aio_config=self.aio_config())\n\n else:\n raise NotImplementedError(\"ZeRO stage {} not implemented\".format(zero_stage))\n\n return optimizer\n\n def _configure_progressive_layer_drop(self):\n pld = ProgressiveLayerDrop(theta=self.pld_theta(), gamma=self.pld_gamma())\n\n return pld\n\n def deepspeed_io(self,\n dataset,\n batch_size=None,\n route=ROUTE_TRAIN,\n pin_memory=True,\n data_sampler=None,\n collate_fn=None,\n num_local_io_workers=None):\n if not isinstance(dataset, torch.utils.data.Dataset):\n raise ValueError(\"Training data must be a torch Dataset\")\n\n if data_sampler is None and (route == ROUTE_PREDICT or route == ROUTE_EVAL):\n data_sampler = torch.utils.data.SequentialSampler(dataset)\n\n if batch_size is None:\n batch_size = self.train_micro_batch_size_per_gpu()\n\n if collate_fn is None:\n collate_fn = self.collate_fn\n\n # Currently we only use timer in train route\n deepspeed_io_timer = None\n if route == ROUTE_TRAIN:\n deepspeed_io_timer = self.tput_timer\n\n # If mpu is provied, forward world size and parallel rank to sampler.\n data_parallel_world_size = None\n data_parallel_rank = None\n if self.mpu is not None:\n data_parallel_world_size = self.mpu.get_data_parallel_world_size()\n data_parallel_rank = self.mpu.get_data_parallel_rank()\n\n return DeepSpeedDataLoader(dataset=dataset,\n batch_size=batch_size,\n pin_memory=pin_memory,\n collate_fn=collate_fn,\n local_rank=self.local_rank,\n tput_timer=deepspeed_io_timer,\n num_local_io_workers=num_local_io_workers,\n data_sampler=data_sampler,\n data_parallel_world_size=data_parallel_world_size,\n data_parallel_rank=data_parallel_rank)\n\n def train(self, mode=True):\n r\"\"\"\n \"\"\"\n\n self.warn_unscaled_loss = True\n self.module.train(mode)\n\n def eval(self):\n r\"\"\"\n \"\"\"\n\n self.warn_unscaled_loss = True\n self.module.train(False)\n\n def _scale_loss(self, prescaled_loss):\n if isinstance(prescaled_loss, torch.Tensor):\n scaled_loss = prescaled_loss / self.gradient_accumulation_steps()\n elif isinstance(prescaled_loss, tuple) or isinstance(prescaled_loss, list):\n scaled_loss = []\n for l in prescaled_loss:\n if isinstance(l, torch.Tensor):\n scaled_loss.append(l / self.gradient_accumulation_steps())\n else:\n scaled_loss.append(l)\n else:\n scaled_loss = prescaled_loss\n if self.warn_unscaled_loss:\n logger.warning(\n f'DeepSpeed unable to scale loss because of type: {type(prescaled_loss)}'\n )\n self.warn_unscaled_loss = False\n\n return scaled_loss\n\n def forward(self, *inputs, **kwargs):\n r\"\"\"Execute forward propagation\n\n Arguments:\n *inputs: Variable length input list\n **kwargs: variable length keyword arguments\n \"\"\"\n if self.flops_profiler_enabled(\n ) and self.global_steps == self.flops_profiler_profile_step(\n ) and self.global_rank == 0:\n self.flops_profiler = FlopsProfiler(self.module)\n self.flops_profiler.start_profile(ignore_list=None)\n\n if self.module.training and self.progressive_layer_drop:\n kwargs.update(self.progressive_layer_drop.get_state())\n\n if self.zero_optimization_partition_weights():\n # Enable automated discovery of external parameters by indicating that\n # we are in a forward pass.\n for module in self.module.modules():\n module._parameters._in_forward = True\n pass\n\n if self.wall_clock_breakdown():\n self.timers('forward_microstep').start()\n self.timers('forward').start()\n\n if self.training_dataloader is None:\n self.tput_timer.start()\n loss = self.module(*inputs, **kwargs)\n\n if self.zero_optimization_partition_weights():\n # Reset the ZeRO-3 state if we are only doing forward-passes (ie evaluation).\n if not torch._C.is_grad_enabled():\n self.optimizer.param_coordinator.reset_step()\n\n # Disable automated discovery of external parameters\n for module in self.module.modules():\n module._parameters._in_forward = False\n\n if self.wall_clock_breakdown():\n self.timers('forward').stop()\n self.timers('forward_microstep').stop()\n\n if self.flops_profiler_enabled(\n ) and self.global_steps == self.flops_profiler_profile_step(\n ) and self.global_rank == 0:\n self.flops_profiler.print_model_profile(\n profile_step=self.global_steps,\n module_depth=self.flops_profiler_module_depth(),\n top_modules=self.flops_profiler_top_modules(),\n detailed=self.flops_profiler_detailed())\n self.flops_profiler.end_profile()\n\n return loss\n\n def allreduce_gradients(self, bucket_size=MEMORY_OPT_ALLREDUCE_SIZE):\n #Zero stage 2 communicates during non gradient accumulation boundaries as well\n if self.zero_optimization_partition_gradients():\n self.optimizer.overlapping_partition_gradients_reduce_epilogue()\n\n #Communicate only at gradient accumulation boundaries\n elif self.is_gradient_accumulation_boundary():\n if self.zero_optimization_stage() == ZERO_OPTIMIZATION_OPTIMIZER_STATES:\n assert self.zero_reduce_scatter()\n self.optimizer.reduce_scatter_gradients(\n postscale_gradients=self.postscale_gradients(),\n gradient_predivide_factor=self.gradient_predivide_factor(),\n gradient_average=self.gradient_average)\n else:\n self.buffered_allreduce_fallback(elements_per_buffer=bucket_size)\n\n def backward(self, loss, allreduce_gradients=True, release_loss=False):\n r\"\"\"Execute backward pass on the loss\n\n Arguments:\n loss: Torch tensor on which to execute backward propagation\n allreduce_gradients: is deprecated, ignored, and will soon be removed'\n \"\"\"\n\n if not allreduce_gradients:\n logger.warning(\n f'Argument `allreduce_gradients` is deprecated, ignored, and will soon be removed'\n )\n\n # scale loss w.r.t. gradient accumulation if needed\n if self.gradient_accumulation_steps() > 1:\n loss = self._scale_loss(loss.float())\n\n # Log training Loss\n if self.tensorboard_enabled():\n if self.is_gradient_accumulation_boundary():\n if self.global_rank == 0:\n self.summary_events = [\n (f'Train/Samples/train_loss',\n loss.mean().item() * self.gradient_accumulation_steps(),\n self.global_samples)\n ]\n for event in self.summary_events: # write_summary_events\n self.summary_writer.add_scalar(event[0], event[1], event[2])\n self.summary_writer.flush()\n\n if self.wall_clock_breakdown():\n self.timers('backward_microstep').start()\n self.timers('backward').start()\n\n assert self.optimizer is not None, \"must provide optimizer during \" \\\n \"init in order to use backward\"\n\n if self.wall_clock_breakdown():\n self.timers('backward_inner_microstep').start()\n self.timers('backward_inner').start()\n\n if self.zero_optimization():\n self.optimizer.is_gradient_accumulation_boundary = self.is_gradient_accumulation_boundary(\n )\n self.optimizer.backward(loss)\n elif self.amp_enabled():\n # AMP requires delaying unscale when inside gradient accumulation boundaries\n # https://nvidia.github.io/apex/advanced.html#gradient-accumulation-across-iterations\n delay_unscale = not self.is_gradient_accumulation_boundary()\n with amp.scale_loss(loss,\n self.optimizer,\n delay_unscale=delay_unscale) as scaled_loss:\n scaled_loss.backward()\n elif self.fp16_enabled():\n self.optimizer.backward(loss)\n else:\n loss.backward()\n\n if self.wall_clock_breakdown():\n self.timers('backward_inner').stop()\n self.timers('backward_inner_microstep').stop()\n\n if self.wall_clock_breakdown():\n self.timers('backward_allreduce_microstep').start()\n self.timers('backward_allreduce').start()\n\n if self.enable_backward_allreduce:\n self.allreduce_gradients()\n\n if self.wall_clock_breakdown():\n self.timers('backward_allreduce').stop()\n self.timers('backward_allreduce_microstep').stop()\n self.timers('backward').stop()\n self.timers('backward_microstep').stop()\n\n if release_loss:\n # loss.data = None\n pass\n\n return loss\n\n def is_gradient_accumulation_boundary(self):\n \"\"\"Query whether the current micro-batch is at the boundary of\n gradient accumulation, and thus will trigger gradient reductions and\n an optimizer step.\n\n Returns:\n bool: if the current step is a gradient accumulation boundary.\n \"\"\"\n return (self.micro_steps + 1) % \\\n self.gradient_accumulation_steps() == 0\n\n def zero_grad(self):\n \"\"\"\n Zero parameter grads.\n \"\"\"\n for param_name, param in self.module.named_parameters():\n param.grad = None\n\n def clip_fp32_gradients(self):\n torch.nn.utils.clip_grad_norm_(parameters=self.module.parameters(),\n max_norm=self.gradient_clipping())\n\n def _take_model_step(self, lr_kwargs):\n if self.gradient_clipping() > 0.0:\n if not self.fp16_enabled() and not self.amp_enabled():\n self.clip_fp32_gradients()\n elif self.amp_enabled():\n # AMP's recommended way of doing clipping\n # https://nvidia.github.io/apex/advanced.html#gradient-clipping\n master_params = amp.master_params(self.optimizer)\n torch.nn.utils.clip_grad_norm_(parameters=master_params,\n max_norm=self.gradient_clipping())\n self.optimizer.step()\n\n #zero grad in basic optimizer could be unreliable and may not exhibit\n #the behaviour that we want\n if not self.zero_optimization() and not self.fp16_enabled(\n ) and not self.amp_enabled():\n self.zero_grad()\n else:\n self.optimizer.zero_grad()\n\n report_progress = self.global_rank == 0 if self.global_rank else True\n\n # Check overlow here since in DS fp16 optimizer, the overflow is updated in above step() function.\n overflow = False\n if hasattr(self.optimizer, 'overflow'):\n overflow = self.optimizer.overflow\n\n if overflow:\n self.skipped_steps += 1\n else:\n if self.lr_scheduler is not None:\n self.lr_scheduler.step(**(lr_kwargs or {}))\n\n if report_progress and (self.global_steps + 1) % self.steps_per_print() == 0:\n self._report_progress(self.global_steps + 1)\n\n self.global_steps += 1\n self.global_samples += self.train_batch_size()\n\n def step(self, lr_kwargs=None):\n r\"\"\"Execute the weight update step after forward and backward propagation\n on effective_train_batch.\n \"\"\"\n if self.wall_clock_breakdown():\n self.timers('step_microstep').start()\n self.timers('step').start()\n\n assert self.optimizer is not None, \"must provide optimizer during \" \\\n \"init in order to use step\"\n report_progress = self.global_rank == 0 if self.global_rank else True\n\n # Update the model when we reach gradient accumulation boundaries\n if self.is_gradient_accumulation_boundary():\n if self.progressive_layer_drop:\n self.progressive_layer_drop.update_state(self.global_steps)\n\n self._take_model_step(lr_kwargs)\n\n self.tput_timer.stop(report_progress)\n\n # Log learning rate\n if self.tensorboard_enabled():\n if self.is_gradient_accumulation_boundary():\n if self.global_rank == 0:\n self.summary_events = [(f'Train/Samples/lr',\n self.get_lr()[0],\n self.global_samples)]\n for event in self.summary_events: # write_summary_events\n self.summary_writer.add_scalar(event[0], event[1], event[2])\n if self.fp16_enabled() and hasattr(self.optimizer, 'cur_scale'):\n self.summary_events.append((f'Train/Samples/loss_scale',\n self.optimizer.cur_scale,\n self.global_samples))\n for event in self.summary_events: # write_summary_events\n self.summary_writer.add_scalar(event[0], event[1], event[2])\n self.summary_writer.flush()\n\n if self.wall_clock_breakdown():\n self.timers('step').stop()\n self.timers('step_microstep').stop()\n timer_names = [\n 'forward_microstep',\n 'backward_microstep',\n 'backward_inner_microstep',\n 'backward_allreduce_microstep',\n 'step_microstep'\n ]\n self.timers.log(names=timer_names, memory_breakdown=self.memory_breakdown())\n\n # Log timing\n if self.is_gradient_accumulation_boundary():\n if self.tensorboard_enabled():\n if self.global_rank == 0:\n self.summary_events = [\n (f'Train/Samples/elapsed_time_ms_forward',\n self.timers('forward').elapsed(reset=False) * 1000.0,\n self.global_samples),\n (f'Train/Samples/elapsed_time_ms_backward',\n self.timers('backward').elapsed(reset=False) * 1000.0,\n self.global_samples),\n (f'Train/Samples/elapsed_time_ms_backward_inner',\n self.timers('backward_inner').elapsed(reset=False) * 1000.0,\n self.global_samples),\n (f'Train/Samples/elapsed_time_ms_backward_allreduce',\n self.timers('backward_allreduce').elapsed(reset=False) *\n 1000.0,\n self.global_samples),\n (f'Train/Samples/elapsed_time_ms_step',\n self.timers('step').elapsed(reset=False) * 1000.0,\n self.global_samples)\n ]\n for event in self.summary_events: # write_summary_events\n self.summary_writer.add_scalar(event[0], event[1], event[2])\n self.summary_writer.flush()\n\n if self.wall_clock_breakdown():\n self.timers.log([\n 'forward',\n 'backward',\n 'backward_inner',\n 'backward_allreduce',\n 'step'\n ])\n\n self.micro_steps += 1\n\n def _get_optimizer_param(self, param_name):\n result = []\n if not self.optimizer:\n return result\n for group in self.optimizer.param_groups:\n if param_name in group:\n result.append(group[param_name])\n else:\n result.append(0.0)\n return result\n\n def get_lr(self):\n return self._get_optimizer_param('lr')\n\n def get_type(self):\n return self._get_optimizer_param('type')\n\n def get_mom(self):\n if self.optimizer_name() in ['SGD', 'RMSprop']:\n return self._get_optimizer_param('momentum')\n else:\n return self._get_optimizer_param('betas')\n\n def get_pld_theta(self):\n if self.progressive_layer_drop:\n return self.progressive_layer_drop.get_theta()\n else:\n return None\n\n def _report_progress(self, step):\n lr = self.get_lr()\n mom = self.get_mom()\n log_dist(f'step={step}, skipped={self.skipped_steps}, lr={lr}, mom={mom}',\n ranks=[0])\n\n def allreduce_bucket(self, bucket):\n tensor = self.flatten(bucket)\n\n tensor_to_allreduce = tensor\n\n if self.allreduce_always_fp32():\n tensor_to_allreduce = tensor.float()\n\n if self.postscale_gradients():\n if self.gradient_predivide_factor() != 1.0:\n tensor_to_allreduce.mul_(1. / self.gradient_predivide_factor())\n\n dist.all_reduce(tensor_to_allreduce, group=self.data_parallel_group)\n\n if self.gradient_average:\n if self.gradient_predivide_factor() != self.dp_world_size:\n tensor_to_allreduce.mul_(self.gradient_predivide_factor() /\n self.dp_world_size)\n else:\n tensor_to_allreduce.div_(self.dp_world_size)\n dist.all_reduce(tensor_to_allreduce, group=self.data_parallel_group)\n\n if self.allreduce_always_fp32() and tensor is not tensor_to_allreduce:\n tensor.copy_(tensor_to_allreduce)\n\n return tensor\n\n def allreduce_and_copy(self, small_bucket):\n allreduced = self.allreduce_bucket(small_bucket)\n for buf, synced in zip(small_bucket, self.unflatten(allreduced, small_bucket)):\n buf.copy_(synced)\n\n def allreduce_no_retain(self, bucket, numel_per_bucket=500000000):\n small_bucket = []\n numel = 0\n for tensor in bucket:\n small_bucket.append(tensor)\n numel = numel + tensor.numel()\n if numel > numel_per_bucket:\n self.allreduce_and_copy(small_bucket)\n small_bucket = []\n numel = 0\n if len(small_bucket) > 0:\n self.allreduce_and_copy(small_bucket)\n\n def buffered_allreduce_fallback(self, grads=None, elements_per_buffer=500000000):\n grads = []\n for param_name, param in self.module.named_parameters():\n if param.grad is None:\n # In cases where there is an imbalance of empty grads across\n # ranks we must create empty grads, this will ensure that every\n # rank is reducing the same size. In some cases it may make\n # sense in the future to support the ability to average not\n # w.r.t. world size but with a different value.\n param.grad = torch.zeros(param.size(),\n dtype=param.dtype,\n device=param.device)\n grads.append(param.grad.data)\n else:\n grad_data = param.grad.data\n if self.sparse_gradients_enabled(\n ) and param_name in self.csr_tensor_module_names:\n grads.append(CSRTensor(grad_data))\n else:\n grads.append(grad_data)\n\n split_buckets = split_half_float_double_csr(grads)\n\n for i, bucket_tuple in enumerate(split_buckets):\n bucket_type, bucket = bucket_tuple\n if bucket_type == CSRTensor.type():\n self.csr_allreduce_no_retain(bucket)\n else:\n self.allreduce_no_retain(bucket, numel_per_bucket=elements_per_buffer)\n\n def csr_allreduce_no_retain(self, bucket):\n allreduced_csrs = self.csr_allreduce_bucket(bucket)\n # Densify csr tensor and copy back to original location\n for csr in allreduced_csrs:\n dense_tensor = csr.to_dense()\n csr.orig_dense_tensor.copy_(dense_tensor)\n\n def csr_allreduce_bucket(self, bucket):\n csr_list = []\n for csr in bucket:\n csr_list.append(self.csr_allreduce(csr))\n return csr_list\n\n def csr_allreduce(self, csr):\n # Pre-divide for fp16 stability\n csr.values.div_(self.dp_world_size)\n\n indices_device_list = self.csr_all_gather(csr.indices)\n values_device_list = self.csr_all_gather(csr.values)\n\n csr.indices = torch.cat(indices_device_list)\n csr.values = torch.cat(values_device_list)\n return csr\n\n def csr_all_gather(self, value):\n my_size = torch.LongTensor([value.size()[0]]).to(self.device)\n all_sizes = self.all_gather_scalar(my_size)\n max_size = torch.cat(all_sizes).max()\n fill_size = (max_size - my_size)\n\n assert value.dim() in [1, 2]\n if value.dim() == 1:\n if fill_size > 0:\n value = torch.cat([value, value.new_zeros(fill_size)])\n tensor_list = [value.new_zeros(max_size) for _ in range(self.dp_world_size)]\n else:\n if fill_size > 0:\n value = torch.cat([value, value.new_zeros(fill_size, value.size()[1])])\n tensor_list = [\n value.new_zeros(max_size,\n value.size()[1]) for _ in range(self.dp_world_size)\n ]\n\n dist.all_gather(tensor_list, value, group=self.data_parallel_group)\n tensors = []\n for dev_idx, t in enumerate(tensor_list):\n size = all_sizes[dev_idx][0]\n tensors.append(\n t.index_select(0,\n torch.LongTensor(range(size)).to(self.device)))\n\n return tensors\n\n def all_gather_scalar(self, value):\n tensor_list = [value.new_zeros(value.size()) for _ in range(self.dp_world_size)]\n dist.all_gather(tensor_list, value, group=self.data_parallel_group)\n return tensor_list\n\n def module_state_dict(self, destination=None, prefix='', keep_vars=False):\n sd = self.module.state_dict(destination, prefix, keep_vars)\n return sd\n\n def load_module_state_dict(self, state_dict, strict=True):\n self.module.load_state_dict(state_dict, strict=strict)\n\n def _get_rank_zero_ckpt_name(self, checkpoints_path, tag, mp_rank, dp_rank):\n filename = 'zero_pp_rank_{}'.format(dp_rank)\n zero_ckpt_name = os.path.join(\n checkpoints_path,\n str(tag),\n filename + '_mp_rank_{:02d}'.format(mp_rank) + '_optim_states.pt')\n return zero_ckpt_name\n\n def _get_zero_ckpt_name(self, checkpoints_path, tag):\n mp_rank = 0 if self.mpu is None else self.mpu.get_model_parallel_rank()\n pp_rank = torch.distributed.get_rank(group=self.optimizer.dp_process_group)\n return self._get_rank_zero_ckpt_name(checkpoints_path, tag, mp_rank, pp_rank)\n\n def _get_ckpt_name(self, checkpoints_path, tag):\n mp_rank = 0 if self.mpu is None else self.mpu.get_model_parallel_rank()\n if self.zero_optimization_partition_weights():\n filename = 'zero_pp_rank_{}'.format(\n torch.distributed.get_rank(group=self.optimizer.dp_process_group))\n ckpt_name = os.path.join(\n checkpoints_path,\n str(tag),\n filename + '_mp_rank_{:02d}'.format(mp_rank) + '_model_states.pt')\n else:\n ckpt_name = os.path.join(\n checkpoints_path,\n str(tag),\n 'mp_rank_{:02d}'.format(mp_rank) + '_model_states.pt')\n return ckpt_name\n\n def load_checkpoint(self,\n load_dir,\n tag=None,\n load_module_strict=True,\n load_optimizer_states=True,\n load_lr_scheduler_states=True):\n \"\"\"Load training checkpoint\n\n Arguments:\n load_dir: Required. Directory to load the checkpoint from\n tag: Checkpoint tag used as a unique identifier for checkpoint, if not provided will attempt to load tag in 'latest' file\n load_module_strict: Optional. Boolean to strictly enforce that the keys in state_dict of module and checkpoint match.\n load_optimizer_states: Optional. Boolean to load the training optimizer states from Checkpoint. Ex. ADAM's momentum and variance\n load_lr_scheduler_states: Optional. Boolean to add the learning rate scheduler states from Checkpoint.\n Returns:\n A tuple of ``load_path`` and ``client_state``.\n\n *``load_path``: Path of the loaded checkpoint. ``None`` if loading the checkpoint failed.\n\n *``client_state``: State dictionary used for loading required training states in the client code.\n \"\"\"\n\n if tag is None:\n latest_path = os.path.join(load_dir, 'latest')\n if os.path.isfile(latest_path):\n with open(latest_path, 'r') as fd:\n tag = fd.read().strip()\n else:\n logger.warning(f\"Unable to find latest file at {latest_path}, if trying to load latest \" \\\n \"checkpoint please ensure this file exists or pass an explicit checkpoint tag when loading a checkpoint.\")\n return None, None\n\n load_path, client_states = self._load_checkpoint(load_dir,\n tag,\n load_module_strict=load_module_strict,\n load_optimizer_states=load_optimizer_states,\n load_lr_scheduler_states=load_lr_scheduler_states)\n\n if self.zero_optimization() and load_path is not None:\n self._load_zero_checkpoint(load_dir,\n tag,\n load_optimizer_states=load_optimizer_states)\n\n return load_path, client_states\n\n def _load_checkpoint(self,\n load_dir,\n tag,\n load_module_strict=True,\n load_optimizer_states=True,\n load_lr_scheduler_states=True):\n\n load_path = self._get_ckpt_name(load_dir, tag)\n\n if not os.path.exists(load_path):\n logger.warn(\n 'Client provided checkpoint load path: {} does not exist ... skip checkpoint load'\n .format(load_path))\n return None, None\n\n logger.info(f'rank: {self.global_rank} loading checkpoint: {load_path}')\n checkpoint = torch.load(load_path, map_location=lambda storage, loc: storage)\n\n if isinstance(self.module, PipelineModule):\n # Pipeline parallelism uses this to load its own checkpoint files.\n self._curr_ckpt_path = os.path.join(load_dir, tag)\n\n self.load_module_state_dict(state_dict=checkpoint['module'],\n strict=load_module_strict)\n if self.optimizer is not None and not self.zero_optimization():\n if self.fp16_enabled():\n self.optimizer.load_state_dict(\n checkpoint['optimizer'],\n load_optimizer_states=load_optimizer_states)\n elif load_optimizer_states:\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n if load_lr_scheduler_states and self.lr_scheduler is not None:\n self.lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n\n self.csr_tensor_module_names = checkpoint['csr_tensor_module_names']\n self.global_steps = checkpoint['global_steps']\n self.global_samples = checkpoint.get('global_samples',\n self.global_steps * self.train_batch_size())\n self.skipped_steps = checkpoint['skipped_steps']\n self.loaded_checkpoint_mp_world_size = checkpoint['mp_world_size']\n self.loaded_checkpoint_dp_world_size = checkpoint['dp_world_size']\n deepspeed_states = [\n 'module',\n 'optimizer',\n 'lr_scheduler',\n 'csr_tensor_module_names',\n 'skipped_steps',\n 'global_steps',\n 'dp_world_size',\n 'mp_world_size'\n ]\n client_state = {\n key: value\n for key,\n value in checkpoint.items() if not key in deepspeed_states\n }\n\n return load_path, client_state\n\n def _load_zero_checkpoint(self, load_dir, tag, load_optimizer_states=True):\n zero_sd_list = self._get_all_zero_checkpoints(load_dir, tag)\n if zero_sd_list is None:\n return\n\n self.optimizer.load_state_dict(\n state_dict_list=zero_sd_list,\n load_optimizer_states=load_optimizer_states,\n load_from_fp32_weights=self.zero_load_from_fp32_weights())\n print(\n f'loading {len(zero_sd_list)} zero partition checkpoints for rank {self.global_rank}'\n )\n\n def _get_mp_rank_zero_checkpoint_names(self, load_dir, tag, mp_rank, dp_world_size):\n zero_ckpt_names = []\n for dp_rank in range(dp_world_size):\n ckpt_name = self._get_rank_zero_ckpt_name(checkpoints_path=load_dir,\n tag=tag,\n mp_rank=mp_rank,\n dp_rank=dp_rank)\n zero_ckpt_names.append(ckpt_name)\n\n return zero_ckpt_names\n\n def _get_all_zero_checkpoint_names(self,\n load_dir,\n tag,\n mp_world_size,\n dp_world_size):\n zero_ckpt_names = []\n for mp_rank in range(mp_world_size):\n mp_rank_ckpt_names = self._get_mp_rank_zero_checkpoint_names(\n load_dir=load_dir,\n tag=tag,\n mp_rank=mp_rank,\n dp_world_size=dp_world_size)\n zero_ckpt_names += mp_rank_ckpt_names\n\n return zero_ckpt_names\n\n def _get_all_zero_checkpoints(self, load_dir, tag):\n mp_rank = 0 if self.mpu is None else self.mpu.get_model_parallel_rank()\n zero_ckpt_names = self._get_mp_rank_zero_checkpoint_names(\n load_dir=load_dir,\n tag=tag,\n mp_rank=mp_rank,\n dp_world_size=self.loaded_checkpoint_dp_world_size)\n invalid_zero_ckpt_paths = []\n for i, ckpt_name in enumerate(zero_ckpt_names):\n if not os.path.exists(ckpt_name):\n # transparently handle the old file pattern for optim_states\n if 'optim_states.pt' in ckpt_name:\n ckpt_name_try = ckpt_name.replace(\"_optim_states.pt\",\n \"optim_states.pt\")\n if os.path.exists(ckpt_name_try):\n zero_ckpt_names[i] = ckpt_name_try\n continue\n invalid_zero_ckpt_paths.append(ckpt_name)\n\n if len(invalid_zero_ckpt_paths) > 0:\n logger.warn(\n f\"The following zero checkpoints paths are missing: {invalid_zero_ckpt_paths}\"\n )\n return None\n\n zero_sd_list = []\n for ckpt_name in zero_ckpt_names:\n zero_sd_list.append(torch.load(ckpt_name, map_location='cpu'))\n\n zero_optimizer_sd = [sd['optimizer_state_dict'] for sd in zero_sd_list]\n print(\n f\"successfully loaded {len(zero_optimizer_sd)} ZeRO state_dicts for rank {self.global_rank}\"\n )\n return zero_optimizer_sd\n\n def _checkpoint_tag_validation(self, tag):\n if self.checkpoint_tag_validation_enabled():\n s_hash = hashlib.sha1(tag.encode())\n bhash = torch.ByteTensor([s_hash.digest()]).flatten().to(self.device)\n max_bhash = bhash.clone()\n min_bhash = bhash.clone()\n dist.all_reduce(max_bhash, op=torch.distributed.ReduceOp.MAX)\n dist.all_reduce(min_bhash, op=torch.distributed.ReduceOp.MIN)\n valid = all(min_bhash == bhash) and all(max_bhash == bhash)\n msg = f\"[rank={dist.get_rank()}] The checkpoint tag name '{tag}' is not consistent across \" \\\n \"all ranks. Including rank unique information in checkpoint tag could cause issues when \" \\\n \"restoring with different world sizes.\"\n if self.checkpoint_tag_validation_fail():\n assert valid, msg\n elif not valid:\n logger.warning(msg)\n\n def save_checkpoint(self, save_dir, tag=None, client_state={}, save_latest=True):\n r\"\"\"Save training checkpoint\n\n Arguments:\n save_dir: Required. Directory for saving the checkpoint\n tag: Optional. Checkpoint tag used as a unique identifier for the checkpoint, global step is\n used if not provided. Tag name must be the same across all ranks.\n client_state: Optional. State dictionary used for saving required training states in the client code.\n save_latest: Optional. Save a file 'latest' pointing to the latest saved checkpoint.\n\n Important: all processes must call this method and not just the process with rank 0. It is\n because each process needs to save its master weights and scheduler+optimizer states. This\n method will hang waiting to synchronize with other processes if it's called just for the\n process with rank 0.\n \"\"\"\n\n if self.zero_optimization_partition_weights():\n # Prepare for state_dict() by ensuring all parameters are partitioned\n self.optimizer.save_checkpoint_prologue()\n\n # This is to make sure the checkpoint names are created without collision\n # There seems to be issue creating them in parallel\n\n # Ensure save_dir directory exists\n os.makedirs(save_dir, exist_ok=True)\n\n if tag is None:\n tag = f\"global_step{self.global_steps}\"\n\n # Ensure tag is a string\n tag = str(tag)\n\n # Ensure checkpoint tag is consistent across ranks\n self._checkpoint_tag_validation(tag)\n\n if self.save_non_zero_checkpoint:\n self._create_checkpoint_file(save_dir, tag, False)\n self._save_checkpoint(save_dir, tag, client_state=client_state)\n\n if self.save_zero_checkpoint:\n self._create_zero_checkpoint_files(save_dir, tag)\n self._save_zero_checkpoint(save_dir, tag)\n\n # Save latest checkpoint tag\n if save_latest:\n with open(os.path.join(save_dir, 'latest'), 'w') as fd:\n fd.write(tag)\n\n if self.zero_optimization_partition_weights():\n self.optimizer.save_checkpoint_epilogue()\n\n return True\n\n def _create_checkpoint_file(self, save_dir, tag, zero_checkpoint):\n name_function = self._get_zero_ckpt_name if zero_checkpoint else self._get_ckpt_name\n try:\n checkpoint_name = name_function(save_dir, tag)\n ensure_directory_exists(checkpoint_name)\n except:\n logger.error(f'Failed saving model checkpoint to {save_dir} with tag {tag}')\n return False\n\n return True\n\n def _create_zero_checkpoint_files(self, save_dir, tag):\n success = True\n # zero checkpoint files are created sequentially\n for rank in range(self.world_size):\n if rank == self.global_rank:\n success = self._create_checkpoint_file(save_dir, tag, True)\n\n dist.barrier()\n\n return success\n\n def _save_checkpoint(self, save_dir, tag, client_state={}):\n\n save_path = self._get_ckpt_name(save_dir, tag)\n # A hack to save the checkpointing directory. Pipeline parallelism overrides\n # module_state_dict() and uses this path to save the model. module_state_dict()\n # then instead just returns None.\n self._curr_ckpt_path = os.path.join(save_dir, tag)\n\n state = dict(\n module=self.module_state_dict(),\n optimizer=self.optimizer.state_dict()\n if self.optimizer and not self.zero_optimization() else None,\n lr_scheduler=self.lr_scheduler.state_dict()\n if self.lr_scheduler is not None else None,\n csr_tensor_module_names=self.csr_tensor_module_names,\n skipped_steps=self.skipped_steps,\n global_steps=self.global_steps,\n global_samples=self.global_samples,\n dp_world_size=self.dp_world_size,\n mp_world_size=self.mp_world_size,\n )\n state.update(client_state)\n\n log_dist(message=f'Saving model checkpoint: {save_path}', ranks=[0])\n #logger.info('Saving model checkpoint: {}'.format(save_path))\n torch.save(state, save_path)\n self._curr_save_path = None\n\n def _get_param_shapes(self):\n param_shapes = OrderedDict()\n for name, param in self.module.named_parameters():\n param_shapes[name] = param.ds_shape if hasattr(param,\n \"ds_shape\") else param.shape\n # print(f\"saving param {name} {param_shapes[name]}\")\n return param_shapes\n\n def _copy_recovery_script(self, save_path):\n base_dir = os.path.dirname(os.path.dirname(__file__))\n script = \"zero_to_fp32.py\"\n src = os.path.join(base_dir, \"utils\", script)\n dst = os.path.join(save_path, script)\n logger.info(f\"creating recovery script {dst}\")\n copyfile(src, dst)\n # make executable\n os.chmod(dst, os.stat(dst).st_mode | stat.S_IEXEC)\n\n def _save_zero_checkpoint(self, save_path, tag):\n zero_checkpoint_name = self._get_zero_ckpt_name(save_path, tag)\n zero_sd = dict(\n optimizer_state_dict=self.optimizer.state_dict(),\n param_shapes=self._get_param_shapes(),\n )\n torch.save(zero_sd, zero_checkpoint_name)\n self._copy_recovery_script(save_path)\n logger.info('zero checkpoint saved {}'.format(zero_checkpoint_name))\n\n def _zero3_consolidated_fp16_state_dict(self):\n \"\"\"\n\n Get a full non-partitioned state_dict with fp16 weights on cpu.\n\n Important: this function must be called on all ranks and not just rank 0.\n\n This is similar to nn.Module.state_dict (modelled after _save_to_state_dict), but:\n\n 1. consolidates the weights from different partitions on gpu0\n 2. works on one layer at a time to require as little gpu0 memory as possible, by\n moving the already consolidated weights to cpu\n 3. takes care to keep the shared params shared when gradually copying the params to cpu\n\n Returns:\n a consolidated fp16 ``state_dict`` on cpu on rank 0, ``None`` on other ranks\n\n \"\"\"\n import deepspeed\n\n if not self.zero_optimization_partition_weights():\n raise ValueError(\"this function requires ZeRO-3 mode\")\n\n state_dict = OrderedDict() if torch.distributed.get_rank() == 0 else None\n shared_weights = {}\n\n def get_layer_state_dict(module, prefix=\"\"):\n # gather one layer at a time to be memory-efficient\n with deepspeed.zero.GatheredParameters(list(\n module.parameters(recurse=False))):\n if torch.distributed.get_rank() == 0:\n for name, param in module.named_parameters(recurse=False):\n if param is None:\n continue\n key = prefix + name\n # for shared weights we want to make sure not to unshare them when copying to cpu\n data_ptr_id = param.storage().data_ptr()\n if data_ptr_id in shared_weights:\n # shared weights\n # print(f\"`{key}` is shared with `{shared_weights[data_ptr_id]}`\")\n state_dict[key] = state_dict[shared_weights[data_ptr_id]]\n else:\n state_dict[key] = param.detach().cpu()\n shared_weights[data_ptr_id] = key\n #print(f\"param {name} {param.shape}\")\n #print(f\"param {key} {param.shape} {state_dict[key].storage().data_ptr()}\")\n\n # now buffers - not sure if need to take care of potentially shared weights here\n for name, buf in module.named_buffers(recurse=False):\n if buf is not None and name not in module._non_persistent_buffers_set:\n state_dict[prefix + name] = buf.detach().cpu()\n\n for name, child in module.named_children():\n if child is not None:\n get_layer_state_dict(child, prefix + name + \".\")\n\n see_memory_usage(\"before get_layer_state_dict\", force=False)\n get_layer_state_dict(self.module, prefix=\"\")\n see_memory_usage(\"after get_layer_state_dict\", force=False)\n\n return state_dict\n\n def save_fp16_model(self, save_dir, save_filename=\"pytorch_model.bin\"):\n r\"\"\"Save fp16 model weights\n\n This method saves the fp16 model weights at the desired destination.\n\n Arguments:\n save_dir: Required. Directory for saving the model\n save_filename: Optional. Filename to save to. Defaults to ``pytorch_model.bin``\n\n Important: all processes must call this method and not just the process with rank 0. It is\n because the processes need to work in sync to gather the weights. This method will hang\n waiting to synchronize with other processes if it's called just for the process with rank 0.\n\n \"\"\"\n\n path = os.path.join(save_dir, save_filename)\n\n if self.zero_optimization_partition_weights():\n if self.zero_gather_fp16_weights_on_model_save():\n # consolidation is expensive in time and memory and therefore isn't a default\n state_dict = self._zero3_consolidated_fp16_state_dict()\n else:\n # the model will be bogus if not consolidated so don't confuse the user by saving it\n logger.info(\n f\"Did not save the model {path} because `stage3_gather_fp16_weights_on_model_save` is False\"\n )\n return\n else:\n state_dict = self.module.state_dict()\n\n if torch.distributed.get_rank() == 0:\n os.makedirs(save_dir, exist_ok=True)\n logger.info(f\"Saving model weights to {path}\")\n torch.save(state_dict, path)\n"
] | [
[
"torch.distributed.get_world_size",
"torch.cat",
"torch.distributed.new_group",
"torch.device",
"torch.optim.AdamW",
"torch.is_tensor",
"torch.save",
"torch.utils.data.SequentialSampler",
"torch.distributed.all_gather",
"torch.optim.Adam",
"torch.cuda.set_device",
"torch.distributed.is_initialized",
"torch.distributed.all_reduce",
"torch.load",
"torch.distributed.get_rank",
"torch.distributed.barrier",
"torch._C.is_grad_enabled",
"torch.distributed.broadcast"
]
] |
notmatthancock/notmatthancock.github.io | [
"abcd91cc7c2653c5243fe96ba2fd681ec03930bb"
] | [
"code/py/test_statsrecorder.py"
] | [
"import numpy as np\nimport statsrecorder as sr\n\nrs = np.random.RandomState(323)\n\nmystats = sr.StatsRecorder()\n\n# Hold all observations in \"data\" to check for correctness.\nndims = 42\ndata = np.empty((0, ndims))\n\nfor i in range(1000):\n nobserv = rs.randint(10,101)\n newdata = rs.randn(nobserv, ndims)\n data = np.vstack((data, newdata))\n\n # Update stats recorder object\n mystats.update(newdata)\n\n # Check stats recorder object is doing its business right.\n assert np.allclose(mystats.mean, data.mean(axis=0))\n assert np.allclose(mystats.std, data.std(axis=0))\n"
] | [
[
"numpy.empty",
"numpy.vstack",
"numpy.random.RandomState"
]
] |
samtygier-stfc/SScanSS-2 | [
"0df2160c32fdc533f7d391735bd55d524e253f4d"
] | [
"sscanss/ui/dialogs/insert.py"
] | [
"import numpy as np\nfrom PyQt5 import QtCore, QtGui, QtWidgets\nfrom sscanss.config import path_for, settings\nfrom sscanss.core.math import Plane, Matrix33, Vector3, clamp, map_range, trunc, VECTOR_EPS\nfrom sscanss.core.geometry import mesh_plane_intersection\nfrom sscanss.core.util import Primitives, DockFlag, StrainComponents, PointType, PlaneOptions, Attributes\nfrom sscanss.ui.widgets import (FormGroup, FormControl, GraphicsView, GraphicsScene, create_tool_button, FormTitle,\n create_scroll_area, CompareValidator, GraphicsPointItem, Grid, create_icon)\nfrom .managers import PointManager\n\n\nclass InsertPrimitiveDialog(QtWidgets.QWidget):\n \"\"\"Provides UI for typing in measurement/fiducial points\n\n :param primitive: primitive type\n :type primitive: Primitives\n :param parent: Main window\n :type parent: MainWindow\n \"\"\"\n dock_flag = DockFlag.Upper\n\n def __init__(self, primitive, parent):\n super().__init__(parent)\n self.parent = parent\n self.parent_model = self.parent.presenter.model\n self.parent.scenes.switchToSampleScene()\n self.primitive = primitive\n\n self.main_layout = QtWidgets.QVBoxLayout()\n\n self.textboxes = {}\n name = self.parent_model.uniqueKey(self.primitive.value)\n self.mesh_args = {'name': name}\n if self.primitive == Primitives.Tube:\n self.mesh_args.update({'outer_radius': 100.000, 'inner_radius': 50.000, 'height': 200.000})\n elif self.primitive == Primitives.Sphere:\n self.mesh_args.update({'radius': 100.000})\n elif self.primitive == Primitives.Cylinder:\n self.mesh_args.update({'radius': 100.000, 'height': 200.000})\n else:\n self.mesh_args.update({'width': 50.000, 'height': 100.000, 'depth': 200.000})\n\n self.createPrimitiveSwitcher()\n self.createFormInputs()\n\n button_layout = QtWidgets.QHBoxLayout()\n self.create_primitive_button = QtWidgets.QPushButton('Create')\n self.create_primitive_button.clicked.connect(self.createPrimiviteButtonClicked)\n button_layout.addWidget(self.create_primitive_button)\n button_layout.addStretch(1)\n\n self.main_layout.addLayout(button_layout)\n self.main_layout.addStretch(1)\n\n self.setLayout(self.main_layout)\n\n self.title = 'Insert {}'.format(self.primitive.value)\n self.setMinimumWidth(450)\n self.textboxes['name'].setFocus()\n\n def createPrimitiveSwitcher(self):\n switcher_layout = QtWidgets.QHBoxLayout()\n switcher = create_tool_button(style_name='MenuButton', status_tip='Open dialog for a different primitive')\n switcher.setArrowType(QtCore.Qt.DownArrow)\n switcher.setPopupMode(QtWidgets.QToolButton.InstantPopup)\n switcher.setMenu(self.parent.primitives_menu)\n switcher_layout.addStretch(1)\n switcher_layout.addWidget(switcher)\n self.main_layout.addLayout(switcher_layout)\n\n def createFormInputs(self):\n self.form_group = FormGroup()\n for key, value in self.mesh_args.items():\n pretty_label = key.replace('_', ' ').title()\n\n if key == 'name':\n control = FormControl(pretty_label, value, required=True)\n control.form_lineedit.textChanged.connect(self.nameCheck)\n else:\n control = FormControl(pretty_label, value, desc='mm', required=True, number=True)\n control.range(0, None, min_exclusive=True)\n\n self.textboxes[key] = control\n self.form_group.addControl(control)\n\n if self.primitive == Primitives.Tube:\n outer_radius = self.textboxes['outer_radius']\n inner_radius = self.textboxes['inner_radius']\n\n outer_radius.compareWith(inner_radius, CompareValidator.Operator.Greater)\n inner_radius.compareWith(outer_radius, CompareValidator.Operator.Less)\n\n self.main_layout.addWidget(self.form_group)\n self.form_group.groupValidation.connect(self.formValidation)\n\n def nameCheck(self, value):\n if self.parent_model.all_sample_key == value:\n self.textboxes['name'].isInvalid(f'\"{self.parent_model.all_sample_key}\" is a reserved name')\n\n def formValidation(self, is_valid):\n if is_valid:\n self.create_primitive_button.setEnabled(True)\n else:\n self.create_primitive_button.setDisabled(True)\n\n def createPrimiviteButtonClicked(self):\n for key, textbox in self.textboxes.items():\n value = textbox.value\n self.mesh_args[key] = value\n\n self.parent.presenter.addPrimitive(self.primitive, self.mesh_args)\n new_name = self.parent_model.uniqueKey(self.primitive.value)\n self.textboxes['name'].value = new_name\n\n\nclass InsertPointDialog(QtWidgets.QWidget):\n \"\"\"Provides UI for typing in measurement/fiducial points\n\n :param point_type: point type\n :type point_type: PointType\n :param parent: Main window\n :type parent: MainWindow\n \"\"\"\n dock_flag = DockFlag.Upper\n\n def __init__(self, point_type, parent):\n super().__init__(parent)\n self.parent = parent\n self.parent_model = parent.presenter.model\n self.parent.scenes.switchToSampleScene()\n self.point_type = point_type\n self.title = 'Add {} Point'.format(point_type.value)\n self.main_layout = QtWidgets.QVBoxLayout()\n unit = 'mm'\n self.form_group = FormGroup()\n self.x_axis = FormControl('X', 0.0, required=True, desc=unit, number=True)\n self.y_axis = FormControl('Y', 0.0, required=True, desc=unit, number=True)\n self.z_axis = FormControl('Z', 0.0, required=True, desc=unit, number=True)\n self.form_group.addControl(self.x_axis)\n self.form_group.addControl(self.y_axis)\n self.form_group.addControl(self.z_axis)\n self.form_group.groupValidation.connect(self.formValidation)\n button_layout = QtWidgets.QHBoxLayout()\n self.execute_button = QtWidgets.QPushButton(self.title)\n self.execute_button.clicked.connect(self.executeButtonClicked)\n button_layout.addWidget(self.execute_button)\n button_layout.addStretch(1)\n\n self.main_layout.addWidget(self.form_group)\n self.main_layout.addLayout(button_layout)\n self.main_layout.addStretch(1)\n self.setLayout(self.main_layout)\n\n self.setMinimumWidth(450)\n\n def formValidation(self, is_valid):\n if is_valid:\n self.execute_button.setEnabled(True)\n else:\n self.execute_button.setDisabled(True)\n\n def executeButtonClicked(self):\n point = [self.x_axis.value, self.y_axis.value, self.z_axis.value]\n self.parent.presenter.addPoints([(point, True)], self.point_type)\n\n\nclass InsertVectorDialog(QtWidgets.QWidget):\n \"\"\"Provides UI for adding measurement vectors using a variety of methods\n\n :param parent: Main window\n :type parent: MainWindow\n \"\"\"\n dock_flag = DockFlag.Upper\n\n def __init__(self, parent):\n super().__init__(parent)\n self.parent = parent\n self.parent_model = parent.presenter.model\n self.parent.scenes.switchToSampleScene()\n self.title = 'Add Measurement Vectors'\n self.main_layout = QtWidgets.QVBoxLayout()\n spacing = 10\n self.main_layout.addSpacing(spacing)\n self.main_layout.addWidget(QtWidgets.QLabel('Measurement Point:'))\n self.points_combobox = QtWidgets.QComboBox()\n self.points_combobox.setView(QtWidgets.QListView())\n self.main_layout.addWidget(self.points_combobox)\n self.updatePointList()\n self.main_layout.addSpacing(spacing)\n\n layout = QtWidgets.QHBoxLayout()\n alignment_layout = QtWidgets.QVBoxLayout()\n alignment_layout.addWidget(QtWidgets.QLabel('Alignment:'))\n self.alignment_combobox = QtWidgets.QComboBox()\n self.alignment_combobox.setView(QtWidgets.QListView())\n self.alignment_combobox.setInsertPolicy(QtWidgets.QComboBox.InsertAtCurrent)\n self.updateAlignment()\n self.alignment_combobox.activated.connect(self.addNewAlignment)\n self.alignment_combobox.currentIndexChanged.connect(self.changeRenderedAlignment)\n alignment_layout.addWidget(self.alignment_combobox)\n alignment_layout.addSpacing(spacing)\n layout.addLayout(alignment_layout)\n\n self.detector_combobox = QtWidgets.QComboBox()\n self.detector_combobox.setView(QtWidgets.QListView())\n self.detector_combobox.addItems(list(self.parent_model.instrument.detectors.keys()))\n if len(self.parent_model.instrument.detectors) > 1:\n detector_layout = QtWidgets.QVBoxLayout()\n detector_layout.addWidget(QtWidgets.QLabel('Detector:'))\n detector_layout.addWidget(self.detector_combobox)\n size = self.detector_combobox.iconSize()\n self.detector_combobox.setItemIcon(0, create_icon(settings.value(settings.Key.Vector_1_Colour), size))\n self.detector_combobox.setItemIcon(1, create_icon(settings.value(settings.Key.Vector_2_Colour), size))\n detector_layout.addSpacing(spacing)\n layout.addSpacing(spacing)\n layout.addLayout(detector_layout)\n\n self.main_layout.addLayout(layout)\n\n self.main_layout.addWidget(QtWidgets.QLabel('Strain Component:'))\n self.component_combobox = QtWidgets.QComboBox()\n self.component_combobox.setView(QtWidgets.QListView())\n strain_components = [s.value for s in StrainComponents]\n self.component_combobox.addItems(strain_components)\n self.component_combobox.currentTextChanged.connect(self.toggleKeyInBox)\n self.main_layout.addWidget(self.component_combobox)\n self.main_layout.addSpacing(spacing)\n\n button_layout = QtWidgets.QHBoxLayout()\n self.execute_button = QtWidgets.QPushButton(self.title)\n self.execute_button.clicked.connect(self.executeButtonClicked)\n button_layout.addWidget(self.execute_button)\n button_layout.addStretch(1)\n\n self.createKeyInBox()\n\n self.reverse_checkbox = QtWidgets.QCheckBox('Reverse Direction of Vector')\n self.main_layout.addWidget(self.reverse_checkbox)\n self.main_layout.addSpacing(spacing)\n\n self.main_layout.addLayout(button_layout)\n self.main_layout.addStretch(1)\n self.setLayout(self.main_layout)\n self.parent_model.measurement_points_changed.connect(self.updatePointList)\n self.parent_model.measurement_vectors_changed.connect(self.updateAlignment)\n self.parent.scenes.rendered_alignment_changed.connect(self.alignment_combobox.setCurrentIndex)\n self.setMinimumWidth(450)\n\n def updatePointList(self):\n self.points_combobox.clear()\n point_list = ['All Points']\n point_list.extend(['{}'.format(i+1) for i in range(self.parent_model.measurement_points.size)])\n self.points_combobox.addItems(point_list)\n\n def updateAlignment(self):\n align_count = self.parent_model.measurement_vectors.shape[2]\n if align_count != self.alignment_combobox.count() - 1:\n self.alignment_combobox.clear()\n alignment_list = ['{}'.format(i + 1) for i in range(align_count)]\n alignment_list.append('Add New...')\n self.alignment_combobox.addItems(alignment_list)\n\n self.alignment_combobox.setCurrentIndex(self.parent.scenes.rendered_alignment)\n\n def addNewAlignment(self, index):\n if index == self.alignment_combobox.count() - 1:\n self.alignment_combobox.insertItem(index, '{}'.format(index + 1))\n self.alignment_combobox.setCurrentIndex(index)\n\n def changeRenderedAlignment(self, index):\n align_count = self.parent_model.measurement_vectors.shape[2]\n if 0 <= index < align_count:\n self.parent.scenes.changeRenderedAlignment(index)\n elif index >= align_count:\n self.parent.scenes.changeVisibility(Attributes.Vectors, False)\n\n def toggleKeyInBox(self, selected_text):\n strain_component = StrainComponents(selected_text)\n if strain_component == StrainComponents.custom:\n self.key_in_box.setVisible(True)\n self.form_group.validateGroup()\n else:\n self.key_in_box.setVisible(False)\n self.execute_button.setEnabled(True)\n\n def createKeyInBox(self):\n self.key_in_box = QtWidgets.QWidget(self)\n layout = QtWidgets.QVBoxLayout()\n\n self.form_group = FormGroup(FormGroup.Layout.Horizontal)\n self.x_axis = FormControl('X', 1.0, required=True, number=True, decimals=7)\n self.x_axis.range(-1.0, 1.0)\n self.y_axis = FormControl('Y', 0.0, required=True, number=True, decimals=7)\n self.y_axis.range(-1.0, 1.0)\n self.z_axis = FormControl('Z', 0.0, required=True, number=True, decimals=7)\n self.z_axis.range(-1.0, 1.0)\n self.form_group.addControl(self.x_axis)\n self.form_group.addControl(self.y_axis)\n self.form_group.addControl(self.z_axis)\n self.form_group.groupValidation.connect(self.formValidation)\n\n layout.addWidget(self.form_group)\n self.key_in_box.setLayout(layout)\n self.main_layout.addWidget(self.key_in_box)\n self.toggleKeyInBox(self.component_combobox.currentText())\n\n def formValidation(self, is_valid):\n self.execute_button.setDisabled(True)\n if is_valid:\n if np.linalg.norm([self.x_axis.value, self.y_axis.value, self.z_axis.value]) > VECTOR_EPS:\n self.x_axis.validation_label.setText('')\n self.execute_button.setEnabled(True)\n else:\n self.x_axis.validation_label.setText('Bad Normal')\n\n def executeButtonClicked(self):\n points = self.points_combobox.currentIndex() - 1\n\n selected_text = self.component_combobox.currentText()\n strain_component = StrainComponents(selected_text)\n\n alignment = self.alignment_combobox.currentIndex()\n detector = self.detector_combobox.currentIndex()\n check_state = self.reverse_checkbox.checkState()\n reverse = True if check_state == QtCore.Qt.Checked else False\n\n if strain_component == StrainComponents.custom:\n vector = [self.x_axis.value, self.y_axis.value, self.z_axis.value]\n else:\n vector = None\n\n self.parent.presenter.addVectors(points, strain_component, alignment, detector,\n key_in=vector, reverse=reverse)\n # New vectors are drawn by the scene manager after function ends\n self.parent.scenes._rendered_alignment = alignment\n\n def closeEvent(self, event):\n self.parent.scenes.changeRenderedAlignment(0)\n event.accept()\n\n\nclass PickPointDialog(QtWidgets.QWidget):\n \"\"\"Provides UI for selecting measurement points on a cross section of the sample\n\n :param parent: Main window\n :type parent: MainWindow\n \"\"\"\n dock_flag = DockFlag.Full\n\n def __init__(self, parent):\n super().__init__(parent)\n self.parent = parent\n self.parent_model = parent.presenter.model\n self.parent.scenes.switchToSampleScene()\n self.title = 'Add Measurement Points Graphically'\n self.setMinimumWidth(500)\n\n self.plane_offset_range = (-1., 1.)\n self.slider_range = (-10000000, 10000000)\n\n self.sample_scale = 20\n self.path_pen = QtGui.QPen(QtGui.QColor(255, 0, 0), 0)\n self.point_pen = QtGui.QPen(QtGui.QColor(200, 0, 0), 0)\n\n self.main_layout = QtWidgets.QVBoxLayout()\n self.setLayout(self.main_layout)\n button_layout = QtWidgets.QHBoxLayout()\n self.help_button = create_tool_button(tooltip='Help', style_name='ToolButton',\n status_tip='Display shortcuts for the cross-section view',\n icon_path=path_for('question.png'))\n self.help_button.clicked.connect(self.showHelp)\n\n self.reset_button = create_tool_button(tooltip='Reset View', style_name='ToolButton',\n status_tip='Reset camera transformation of the cross-section view',\n icon_path=path_for('refresh.png'))\n self.execute_button = QtWidgets.QPushButton('Add Points')\n self.execute_button.clicked.connect(self.addPoints)\n button_layout.addWidget(self.help_button)\n button_layout.addWidget(self.reset_button)\n button_layout.addStretch(1)\n button_layout.addWidget(self.execute_button)\n self.main_layout.addLayout(button_layout)\n\n self.splitter = QtWidgets.QSplitter(QtCore.Qt.Vertical)\n self.splitter.setChildrenCollapsible(False)\n self.main_layout.addWidget(self.splitter)\n self.createGraphicsView()\n self.reset_button.clicked.connect(self.view.reset)\n self.createControlPanel()\n\n self.prepareMesh()\n self.parent_model.sample_changed.connect(self.prepareMesh)\n self.parent_model.measurement_points_changed.connect(self.updateCrossSection)\n self.initializing = True\n\n def showEvent(self, event):\n if self.initializing:\n self.view.fitInView(self.view.anchor, QtCore.Qt.KeepAspectRatio)\n self.initializing = False\n\n super().showEvent(event)\n\n def closeEvent(self, event):\n self.parent.scenes.removePlane()\n event.accept()\n\n def prepareMesh(self):\n self.mesh = None\n samples = self.parent_model.sample\n for _, sample in samples.items():\n if self.mesh is None:\n self.mesh = sample.copy()\n else:\n self.mesh.append(sample)\n\n self.scene.clear()\n self.tabs.setEnabled(self.mesh is not None)\n if self.mesh is not None:\n self.setPlane(self.plane_combobox.currentText())\n else:\n self.parent.scenes.removePlane()\n self.view.reset()\n\n def updateStatusBar(self, point):\n if self.view.rect().contains(point):\n transform = self.view.scene_transform.inverted()[0]\n scene_pt = transform.map(self.view.mapToScene(point)) / self.sample_scale\n world_pt = [scene_pt.x(), scene_pt.y(), -self.old_distance] @ self.matrix.transpose()\n cursor_text = f'X: {world_pt[0]:.3f} Y: {world_pt[1]:.3f} Z: {world_pt[2]:.3f}'\n self.parent.cursor_label.setText(cursor_text)\n else:\n self.parent.cursor_label.clear()\n\n def createGraphicsView(self):\n self.scene = GraphicsScene(self.sample_scale, self)\n self.view = GraphicsView(self.scene)\n self.view.mouse_moved.connect(self.updateStatusBar)\n self.view.setMinimumHeight(350)\n self.splitter.addWidget(self.view)\n\n def createControlPanel(self):\n self.tabs = QtWidgets.QTabWidget()\n self.tabs.setMinimumHeight(250)\n self.tabs.setTabPosition(QtWidgets.QTabWidget.South)\n self.splitter.addWidget(self.tabs)\n\n self.createPlaneTab()\n self.createSelectionToolsTab()\n self.createGridOptionsTab()\n point_manager = PointManager(PointType.Measurement, self.parent)\n self.tabs.addTab(create_scroll_area(point_manager), 'Point Manager')\n\n def createPlaneTab(self):\n layout = QtWidgets.QVBoxLayout()\n layout.addWidget(QtWidgets.QLabel('Specify Plane:'))\n self.plane_combobox = QtWidgets.QComboBox()\n self.plane_combobox.setView(QtWidgets.QListView())\n self.plane_combobox.addItems([p.value for p in PlaneOptions])\n self.plane_combobox.currentTextChanged.connect(self.setPlane)\n self.createCustomPlaneBox()\n layout.addWidget(self.plane_combobox)\n layout.addWidget(self.custom_plane_widget)\n layout.addSpacing(20)\n\n slider_layout = QtWidgets.QHBoxLayout()\n slider_layout.addWidget(QtWidgets.QLabel('Plane Distance from Origin (mm):'))\n self.plane_lineedit = QtWidgets.QLineEdit()\n validator = QtGui.QDoubleValidator(self.plane_lineedit)\n validator.setNotation(QtGui.QDoubleValidator.StandardNotation)\n validator.setDecimals(3)\n self.plane_lineedit.setValidator(validator)\n self.plane_lineedit.textEdited.connect(self.updateSlider)\n self.plane_lineedit.editingFinished.connect(self.movePlane)\n slider_layout.addStretch(1)\n slider_layout.addWidget(self.plane_lineedit)\n layout.addLayout(slider_layout)\n self.plane_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)\n self.plane_slider.setMinimum(self.slider_range[0])\n self.plane_slider.setMaximum(self.slider_range[1])\n self.plane_slider.setFocusPolicy(QtCore.Qt.StrongFocus)\n self.plane_slider.setSingleStep(1)\n self.plane_slider.sliderMoved.connect(self.updateLineEdit)\n self.plane_slider.sliderReleased.connect(self.movePlane)\n layout.addWidget(self.plane_slider)\n layout.addStretch(1)\n\n plane_tab = QtWidgets.QWidget()\n plane_tab.setLayout(layout)\n self.tabs.addTab(create_scroll_area(plane_tab), 'Define Plane')\n\n def createSelectionToolsTab(self):\n layout = QtWidgets.QVBoxLayout()\n selector_layout = QtWidgets.QHBoxLayout()\n selector_layout.addWidget(QtWidgets.QLabel('Select Geometry of Points: '))\n self.button_group = QtWidgets.QButtonGroup()\n self.button_group.buttonClicked[int].connect(self.changeSceneMode)\n\n self.object_selector = create_tool_button(checkable=True, checked=True, tooltip='Select Points',\n status_tip='Select movable points from the cross-section view',\n style_name='MidToolButton', icon_path=path_for('select.png'))\n self.point_selector = create_tool_button(checkable=True, tooltip='Draw a Point',\n status_tip='Draw a single point at the selected position',\n style_name='MidToolButton', icon_path=path_for('point.png'))\n self.line_selector = create_tool_button(checkable=True, tooltip='Draw Points on Line',\n status_tip='Draw equally spaced points on the selected line',\n style_name='MidToolButton', icon_path=path_for('line_tool.png'))\n self.area_selector = create_tool_button(checkable=True, tooltip='Draw Points on Area',\n status_tip='Draw a grid of points on the selected area',\n style_name='MidToolButton', icon_path=path_for('area_tool.png'))\n\n self.button_group.addButton(self.object_selector, GraphicsScene.Mode.Select.value)\n self.button_group.addButton(self.point_selector, GraphicsScene.Mode.Draw_point.value)\n self.button_group.addButton(self.line_selector, GraphicsScene.Mode.Draw_line.value)\n self.button_group.addButton(self.area_selector, GraphicsScene.Mode.Draw_area.value)\n selector_layout.addWidget(self.object_selector)\n selector_layout.addWidget(self.point_selector)\n selector_layout.addWidget(self.line_selector)\n selector_layout.addWidget(self.area_selector)\n selector_layout.addStretch(1)\n\n self.createLineToolWidget()\n self.createAreaToolWidget()\n\n layout.addLayout(selector_layout)\n layout.addWidget(self.line_tool_widget)\n layout.addWidget(self.area_tool_widget)\n layout.addStretch(1)\n\n select_tab = QtWidgets.QWidget()\n select_tab.setLayout(layout)\n self.tabs.addTab(create_scroll_area(select_tab), 'Selection Tools')\n\n def createGridOptionsTab(self):\n layout = QtWidgets.QVBoxLayout()\n self.show_grid_checkbox = QtWidgets.QCheckBox('Show Grid')\n self.show_grid_checkbox.stateChanged.connect(self.showGrid)\n self.snap_to_grid_checkbox = QtWidgets.QCheckBox('Snap Selection to Grid')\n self.snap_to_grid_checkbox.stateChanged.connect(self.snapToGrid)\n self.snap_to_grid_checkbox.setEnabled(self.view.show_grid)\n layout.addWidget(self.show_grid_checkbox)\n layout.addWidget(self.snap_to_grid_checkbox)\n self.createGridWidget()\n layout.addWidget(self.grid_widget)\n layout.addStretch(1)\n\n grid_tab = QtWidgets.QWidget()\n grid_tab.setLayout(layout)\n self.tabs.addTab(create_scroll_area(grid_tab), 'Grid Options')\n\n def createCustomPlaneBox(self):\n self.custom_plane_widget = QtWidgets.QWidget(self)\n layout = QtWidgets.QVBoxLayout()\n\n self.form_group = FormGroup(FormGroup.Layout.Horizontal)\n self.x_axis = FormControl('X', 1.0, required=True, number=True)\n self.x_axis.range(-1.0, 1.0)\n self.y_axis = FormControl('Y', 0.0, required=True, number=True)\n self.y_axis.range(-1.0, 1.0)\n self.z_axis = FormControl('Z', 0.0, required=True, number=True)\n self.z_axis.range(-1.0, 1.0)\n self.form_group.addControl(self.x_axis)\n self.form_group.addControl(self.y_axis)\n self.form_group.addControl(self.z_axis)\n self.form_group.groupValidation.connect(self.setCustomPlane)\n\n layout.addWidget(self.form_group)\n self.custom_plane_widget.setLayout(layout)\n\n def createLineToolWidget(self):\n self.line_tool_widget = QtWidgets.QWidget(self)\n layout = QtWidgets.QHBoxLayout()\n layout.setContentsMargins(0, 20, 0, 0)\n layout.addWidget(QtWidgets.QLabel('Number of Points: '))\n self.line_point_count_spinbox = QtWidgets.QSpinBox()\n self.line_point_count_spinbox.setValue(self.scene.line_tool_size)\n self.line_point_count_spinbox.setRange(2, 100)\n self.line_point_count_spinbox.valueChanged.connect(self.scene.setLineToolSize)\n\n layout.addWidget(self.line_point_count_spinbox)\n self.line_tool_widget.setVisible(False)\n self.line_tool_widget.setLayout(layout)\n\n def createAreaToolWidget(self):\n self.area_tool_widget = QtWidgets.QWidget(self)\n layout = QtWidgets.QHBoxLayout()\n layout.setContentsMargins(0, 20, 0, 0)\n layout.addWidget(QtWidgets.QLabel('Number of Points: '))\n self.area_x_spinbox = QtWidgets.QSpinBox()\n self.area_x_spinbox.setValue(self.scene.area_tool_size[0])\n self.area_x_spinbox.setRange(2, 100)\n self.area_y_spinbox = QtWidgets.QSpinBox()\n self.area_y_spinbox.setValue(self.scene.area_tool_size[1])\n self.area_y_spinbox.setRange(2, 100)\n\n stretch_factor = 3\n layout.addStretch(1)\n layout.addWidget(QtWidgets.QLabel('X: '))\n self.area_x_spinbox.valueChanged.connect(lambda: self.scene.setAreaToolSize(self.area_x_spinbox.value(),\n self.area_y_spinbox.value()))\n layout.addWidget(self.area_x_spinbox, stretch_factor)\n layout.addStretch(1)\n layout.addWidget(QtWidgets.QLabel('Y: '))\n self.area_y_spinbox.valueChanged.connect(lambda: self.scene.setAreaToolSize(self.area_x_spinbox.value(),\n self.area_y_spinbox.value()))\n layout.addWidget(self.area_y_spinbox, stretch_factor)\n self.area_tool_widget.setVisible(False)\n self.area_tool_widget.setLayout(layout)\n\n def createGridWidget(self):\n self.grid_widget = QtWidgets.QWidget(self)\n main_layout = QtWidgets.QVBoxLayout()\n main_layout.setContentsMargins(0, 20, 0, 0)\n layout = QtWidgets.QHBoxLayout()\n layout.addWidget(QtWidgets.QLabel('Grid Type: '))\n grid_combobox = QtWidgets.QComboBox()\n grid_combobox.setView(QtWidgets.QListView())\n grid_combobox.addItems([g.value for g in Grid.Type])\n grid_combobox.currentTextChanged.connect(lambda value: self.setGridType(Grid.Type(value)))\n layout.addWidget(grid_combobox)\n main_layout.addLayout(layout)\n main_layout.addSpacing(20)\n\n layout = QtWidgets.QHBoxLayout()\n layout.addWidget(QtWidgets.QLabel('Grid Size: '))\n self.grid_x_label = QtWidgets.QLabel('')\n self.grid_x_spinbox = QtWidgets.QDoubleSpinBox()\n self.grid_x_spinbox.setDecimals(1)\n self.grid_x_spinbox.setSingleStep(0.1)\n self.grid_x_spinbox.valueChanged.connect(self.changeGridSize)\n self.grid_y_label = QtWidgets.QLabel('')\n self.grid_y_spinbox = QtWidgets.QDoubleSpinBox()\n self.grid_y_spinbox.setDecimals(1)\n self.grid_y_spinbox.setSingleStep(0.1)\n self.grid_y_spinbox.valueChanged.connect(self.changeGridSize)\n stretch_factor = 3\n layout.addStretch(1)\n layout.addWidget(self.grid_x_label)\n layout.addWidget(self.grid_x_spinbox, stretch_factor)\n layout.addStretch(1)\n layout.addWidget(self.grid_y_label)\n layout.addWidget(self.grid_y_spinbox, stretch_factor)\n main_layout.addLayout(layout)\n self.setGridType(self.view.grid.type)\n self.grid_widget.setVisible(False)\n self.grid_widget.setLayout(main_layout)\n\n def changeGridSize(self):\n if self.view.grid.type == Grid.Type.Box:\n grid_x = int(self.grid_x_spinbox.value() * self.sample_scale)\n grid_y = int(self.grid_y_spinbox.value() * self.sample_scale)\n else:\n grid_x = int(self.grid_x_spinbox.value() * self.sample_scale)\n grid_y = self.grid_y_spinbox.value()\n self.view.setGridSize((grid_x, grid_y))\n\n def setGridType(self, grid_type):\n self.view.setGridType(grid_type)\n size = self.view.grid.size\n if grid_type == Grid.Type.Box:\n self.grid_x_label.setText('X (mm): ')\n self.grid_y_label.setText('Y (mm): ')\n self.grid_x_spinbox.setValue(size[0])\n self.grid_y_spinbox.setValue(size[1])\n self.grid_x_spinbox.setRange(0.1, 1000)\n self.grid_y_spinbox.setRange(0.1, 1000)\n else:\n self.grid_x_label.setText('Radius (mm): ')\n self.grid_y_label.setText('Angle (degree): ')\n self.grid_x_spinbox.setValue(size[0])\n self.grid_y_spinbox.setValue(size[1])\n self.grid_x_spinbox.setRange(0.1, 1000)\n self.grid_y_spinbox.setRange(0.1, 360)\n\n def changeSceneMode(self, button_id):\n self.scene.mode = GraphicsScene.Mode(button_id)\n self.line_tool_widget.setVisible(self.scene.mode == GraphicsScene.Mode.Draw_line)\n self.area_tool_widget.setVisible(self.scene.mode == GraphicsScene.Mode.Draw_area)\n\n def showHelp(self):\n self.view.show_help = False if self.view.has_foreground else True\n self.scene.update()\n\n def showGrid(self, state):\n self.view.show_grid = True if state == QtCore.Qt.Checked else False\n self.snap_to_grid_checkbox.setEnabled(self.view.show_grid)\n self.grid_widget.setVisible(self.view.show_grid)\n self.scene.update()\n\n def snapToGrid(self, state):\n self.view.snap_to_grid = True if state == QtCore.Qt.Checked else False\n\n def updateSlider(self, value):\n if not self.plane_lineedit.hasAcceptableInput():\n return\n\n new_distance = clamp(float(value), *self.plane_offset_range)\n slider_value = int(map_range(*self.plane_offset_range, *self.slider_range, new_distance))\n self.plane_slider.setValue(slider_value)\n\n offset = new_distance - self.old_distance\n self.parent.scenes.movePlane(offset * self.plane.normal)\n self.old_distance = new_distance\n\n def updateLineEdit(self, value):\n new_distance = trunc(map_range(*self.slider_range, *self.plane_offset_range, value), 3)\n self.plane_lineedit.setText('{:.3f}'.format(new_distance))\n\n offset = new_distance - self.old_distance\n self.parent.scenes.movePlane(offset * self.plane.normal)\n self.old_distance = new_distance\n\n def movePlane(self):\n distance = clamp(float(self.plane_lineedit.text()), *self.plane_offset_range)\n self.plane_lineedit.setText('{:.3f}'.format(distance))\n point = distance * self.plane.normal\n self.plane = Plane(self.plane.normal, point)\n self.updateCrossSection()\n\n def setCustomPlane(self, is_valid):\n if is_valid:\n normal = np.array([self.x_axis.value, self.y_axis.value, self.z_axis.value])\n try:\n self.initializePlane(normal, self.mesh.bounding_box.center)\n except ValueError:\n self.x_axis.validation_label.setText('Bad Normal')\n\n def setPlane(self, selected_text):\n if selected_text == PlaneOptions.Custom.value:\n self.custom_plane_widget.setVisible(True)\n self.form_group.validateGroup()\n return\n else:\n self.custom_plane_widget.setVisible(False)\n\n if selected_text == PlaneOptions.XY.value:\n plane_normal = np.array([0., 0., 1.])\n elif selected_text == PlaneOptions.XZ.value:\n plane_normal = np.array([0., 1., 0.])\n else:\n plane_normal = np.array([1., 0., 0.])\n\n self.initializePlane(plane_normal, self.mesh.bounding_box.center)\n\n def initializePlane(self, plane_normal, plane_point):\n self.plane = Plane(plane_normal, plane_point)\n plane_size = self.mesh.bounding_box.radius\n\n self.parent.scenes.drawPlane(self.plane, 2 * plane_size, 2 * plane_size)\n distance = self.plane.distanceFromOrigin()\n self.plane_offset_range = (distance - plane_size, distance + plane_size)\n slider_value = int(map_range(*self.plane_offset_range, *self.slider_range, distance))\n self.plane_slider.setValue(slider_value)\n self.plane_lineedit.setText('{:.3f}'.format(distance))\n self.old_distance = distance\n # inverted the normal so that the y-axis is flipped\n self.matrix = self.__lookAt(-Vector3(self.plane.normal))\n self.view.resetTransform()\n self.updateCrossSection()\n\n def updateCrossSection(self):\n self.scene.clear()\n segments = mesh_plane_intersection(self.mesh, self.plane)\n if len(segments) == 0:\n return\n segments = np.array(segments)\n\n item = QtWidgets.QGraphicsPathItem()\n cross_section_path = QtGui.QPainterPath()\n rotated_segments = self.sample_scale * (segments @ self.matrix)\n for i in range(0, rotated_segments.shape[0], 2):\n start = rotated_segments[i, :]\n cross_section_path.moveTo(start[0], start[1])\n end = rotated_segments[i + 1, :]\n cross_section_path.lineTo(end[0], end[1])\n item.setPath(cross_section_path)\n item.setPen(self.path_pen)\n item.setTransform(self.view.scene_transform)\n self.scene.addItem(item)\n rect = item.boundingRect()\n anchor = rect.center()\n\n ab = self.plane.point - self.parent_model.measurement_points.points\n d = np.einsum('ij,ij->i', np.expand_dims(self.plane.normal, axis=0), ab)\n index = np.where(np.abs(d) < VECTOR_EPS)[0]\n rotated_points = self.parent_model.measurement_points.points[index, :]\n rotated_points = rotated_points @ self.matrix\n\n for i, p in zip(index, rotated_points):\n point = QtCore.QPointF(p[0], p[1]) * self.sample_scale\n point = self.view.scene_transform.map(point)\n item = GraphicsPointItem(point, size=self.scene.point_size)\n item.setToolTip(f'Point {i + 1}')\n item.fixed = True\n item.makeControllable(self.scene.mode == GraphicsScene.Mode.Select)\n item.setPen(self.point_pen)\n self.scene.addItem(item)\n rect = rect.united(item.boundingRect().translated(point))\n\n # calculate new rectangle that encloses original rect with a different anchor\n rect.united(rect.translated(anchor - rect.center()))\n self.view.setSceneRect(rect)\n self.view.fitInView(rect, QtCore.Qt.KeepAspectRatio)\n self.view.anchor = rect\n\n @staticmethod\n def __lookAt(forward):\n rot_matrix = Matrix33.identity()\n up = Vector3([0., -1., 0.]) if -VECTOR_EPS < forward[1] < VECTOR_EPS else Vector3([0., 0., 1.])\n left = up ^ forward\n left.normalize()\n up = forward ^ left\n\n rot_matrix.c1[:3] = left\n rot_matrix.c2[:3] = up\n rot_matrix.c3[:3] = forward\n\n return rot_matrix\n\n def addPoints(self):\n if len(self.scene.items()) < 2:\n return\n\n points_2d = []\n transform = self.view.scene_transform.inverted()[0]\n for item in self.scene.items():\n if isinstance(item, GraphicsPointItem) and not item.fixed:\n pos = transform.map(item.pos()) / self.sample_scale\n # negate distance due to inverted normal when creating matrix\n points_2d.append([pos.x(), pos.y(), -self.old_distance])\n self.scene.removeItem(item)\n\n if not points_2d:\n return\n\n points = points_2d[::-1] @ self.matrix.transpose()\n enabled = [True] * points.shape[0]\n self.parent.presenter.addPoints(list(zip(points, enabled)), PointType.Measurement, False)\n\n\nclass AlignSample(QtWidgets.QWidget):\n \"\"\"Provides UI for aligning sample on instrument with 6D pose\n\n :param parent: Main window\n :type parent: MainWindow\n \"\"\"\n dock_flag = DockFlag.Upper\n\n def __init__(self, parent):\n super().__init__(parent)\n self.parent = parent\n self.parent.scenes.switchToInstrumentScene()\n self.title = 'Align Sample with 6D pose'\n self.setMinimumWidth(450)\n\n self.main_layout = QtWidgets.QVBoxLayout()\n self.setLayout(self.main_layout)\n self.main_layout.addSpacing(20)\n self.main_layout.addWidget(FormTitle('Create Transformation for Alignment'))\n self.main_layout.addSpacing(10)\n\n self.main_layout.addWidget(QtWidgets.QLabel('Translation along the X, Y, and Z axis (mm):'))\n self.position_form_group = FormGroup(FormGroup.Layout.Horizontal)\n self.x_position = FormControl('X', 0.0, required=True, number=True)\n self.y_position = FormControl('Y', 0.0, required=True, number=True)\n self.z_position = FormControl('Z', 0.0, required=True, number=True)\n self.position_form_group.addControl(self.x_position)\n self.position_form_group.addControl(self.y_position)\n self.position_form_group.addControl(self.z_position)\n self.position_form_group.groupValidation.connect(self.formValidation)\n self.main_layout.addWidget(self.position_form_group)\n\n self.main_layout.addWidget(QtWidgets.QLabel('Rotation around the X, Y, and Z axis (degrees):'))\n self.orientation_form_group = FormGroup(FormGroup.Layout.Horizontal)\n self.x_rotation = FormControl('X', 0.0, required=True, number=True)\n self.x_rotation.range(-360.0, 360.0)\n self.y_rotation = FormControl('Y', 0.0, required=True, number=True)\n self.y_rotation.range(-360.0, 360.0)\n self.z_rotation = FormControl('Z', 0.0, required=True, number=True)\n self.z_rotation.range(-360.0, 360.0)\n self.orientation_form_group.addControl(self.x_rotation)\n self.orientation_form_group.addControl(self.y_rotation)\n self.orientation_form_group.addControl(self.z_rotation)\n self.orientation_form_group.groupValidation.connect(self.formValidation)\n self.main_layout.addWidget(self.orientation_form_group)\n\n button_layout = QtWidgets.QHBoxLayout()\n self.execute_button = QtWidgets.QPushButton('Align Sample')\n self.execute_button.clicked.connect(self.executeButtonClicked)\n button_layout.addWidget(self.execute_button)\n button_layout.addStretch(1)\n self.main_layout.addLayout(button_layout)\n self.main_layout.addStretch(1)\n\n def formValidation(self):\n if self.position_form_group.valid and self.orientation_form_group.valid:\n self.execute_button.setEnabled(True)\n else:\n self.execute_button.setDisabled(True)\n\n def executeButtonClicked(self):\n pose = [self.x_position.value, self.y_position.value, self.z_position.value,\n self.z_rotation.value, self.y_rotation.value, self.x_rotation.value]\n\n self.parent.presenter.alignSampleWithPose(pose)\n"
] | [
[
"numpy.array",
"numpy.linalg.norm",
"numpy.expand_dims",
"numpy.abs"
]
] |
cnheider/onnx | [
"f5bb59aa0f8b18b602763abe47d1d24d0d54b197",
"781545783a4e2bbbda48fc64318fb2c6d8bbb3cc",
"f5bb59aa0f8b18b602763abe47d1d24d0d54b197",
"8e9c7d57f7c5aa6f6eb7ee7abb0ba2a243781933"
] | [
"onnx/backend/test/case/node/batchnorm.py",
"onnx/backend/test/case/base.py",
"onnx/backend/test/case/node/isnan.py",
"onnx/backend/test/case/node/max.py"
] | [
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport numpy as np # type: ignore\n\nimport onnx\nfrom ..base import Base\nfrom . import expect\n\n\nclass BatchNormalization(Base):\n\n @staticmethod\n def export(): # type: () -> None\n def _batchnorm_test_mode(x, s, bias, mean, var, epsilon=1e-5): # type: ignore\n dims_x = len(x.shape)\n dim_ones = (1,) * (dims_x - 2)\n s = s.reshape(-1, *dim_ones)\n bias = bias.reshape(-1, *dim_ones)\n mean = mean.reshape(-1, *dim_ones)\n var = var.reshape(-1, *dim_ones)\n return s * (x - mean) / np.sqrt(var + epsilon) + bias\n\n # input size: (1, 2, 1, 3)\n x = np.array([[[[-1, 0, 1]], [[2, 3, 4]]]]).astype(np.float32)\n s = np.array([1.0, 1.5]).astype(np.float32)\n bias = np.array([0, 1]).astype(np.float32)\n mean = np.array([0, 3]).astype(np.float32)\n var = np.array([1, 1.5]).astype(np.float32)\n y = _batchnorm_test_mode(x, s, bias, mean, var).astype(np.float32)\n\n node = onnx.helper.make_node(\n 'BatchNormalization',\n inputs=['x', 's', 'bias', 'mean', 'var'],\n outputs=['y'],\n )\n\n # output size: (1, 2, 1, 3)\n expect(node, inputs=[x, s, bias, mean, var], outputs=[y],\n name='test_batchnorm_example')\n\n # input size: (2, 3, 4, 5)\n x = np.random.randn(2, 3, 4, 5).astype(np.float32)\n s = np.random.randn(3).astype(np.float32)\n bias = np.random.randn(3).astype(np.float32)\n mean = np.random.randn(3).astype(np.float32)\n var = np.random.rand(3).astype(np.float32)\n epsilon = 1e-2\n y = _batchnorm_test_mode(x, s, bias, mean, var, epsilon).astype(np.float32)\n\n node = onnx.helper.make_node(\n 'BatchNormalization',\n inputs=['x', 's', 'bias', 'mean', 'var'],\n outputs=['y'],\n epsilon=epsilon,\n )\n\n # output size: (2, 3, 4, 5)\n expect(node, inputs=[x, s, bias, mean, var], outputs=[y],\n name='test_batchnorm_epsilon')\n",
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nfrom collections import defaultdict\nimport inspect\nfrom textwrap import dedent\nfrom typing import Dict, Text, List, Tuple, Type, Sequence, Any\n\nimport numpy as np # type: ignore\nfrom six import add_metaclass\n\n\ndef process_snippet(op_name, name, export): # type: (Text, Text, Any) -> Tuple[Text, Text]\n snippet_name = name[len('export_'):] or op_name.lower()\n source_code = dedent(inspect.getsource(export))\n # remove the function signature line\n lines = source_code.splitlines()\n assert lines[0] == '@staticmethod'\n assert lines[1].startswith('def export')\n return snippet_name, dedent(\"\\n\".join(lines[2:]))\n\n\nSnippets = defaultdict(list) # type: Dict[Text, List[Tuple[Text, Text]]]\n\n\nclass _Exporter(type):\n exports = defaultdict(list) # type: Dict[Text, List[Tuple[Text, Text]]]\n\n def __init__(cls, name, bases, dct): # type: (str, Tuple[Type[Any], ...], Dict[str, Any]) -> None\n for k, v in dct.items():\n if k.startswith('export'):\n if not isinstance(v, staticmethod):\n raise ValueError(\n 'Only staticmethods could be named as export.*')\n export = getattr(cls, k)\n Snippets[name].append(process_snippet(name, k, export))\n # export functions should call expect and so populate\n # TestCases\n np.random.seed(seed=0)\n export()\n super(_Exporter, cls).__init__(name, bases, dct)\n\n\n@add_metaclass(_Exporter)\nclass Base(object):\n pass\n",
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport numpy as np # type: ignore\n\nimport onnx\nfrom ..base import Base\nfrom . import expect\n\n\nclass IsNaN(Base):\n\n @staticmethod\n def export(): # type: () -> None\n node = onnx.helper.make_node(\n 'IsNaN',\n inputs=['x'],\n outputs=['y'],\n )\n\n x = np.array([3.0, np.nan, 4.0, np.nan], dtype=np.float32)\n y = np.isnan(x)\n expect(node, inputs=[x], outputs=[y], name='test_isnan')\n",
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport numpy as np # type: ignore\n\nimport onnx\nfrom ..base import Base\nfrom . import expect\nfrom ..utils import all_numeric_dtypes\n\n\nclass Max(Base):\n\n @staticmethod\n def export(): # type: () -> None\n data_0 = np.array([3, 2, 1]).astype(np.float32)\n data_1 = np.array([1, 4, 4]).astype(np.float32)\n data_2 = np.array([2, 5, 3]).astype(np.float32)\n result = np.array([3, 5, 4]).astype(np.float32)\n node = onnx.helper.make_node(\n 'Max',\n inputs=['data_0', 'data_1', 'data_2'],\n outputs=['result'],\n )\n expect(node, inputs=[data_0, data_1, data_2], outputs=[result],\n name='test_max_example')\n\n node = onnx.helper.make_node(\n 'Max',\n inputs=['data_0'],\n outputs=['result'],\n )\n expect(node, inputs=[data_0], outputs=[data_0],\n name='test_max_one_input')\n\n result = np.maximum(data_0, data_1)\n node = onnx.helper.make_node(\n 'Max',\n inputs=['data_0', 'data_1'],\n outputs=['result'],\n )\n expect(node, inputs=[data_0, data_1], outputs=[result],\n name='test_max_two_inputs')\n\n @staticmethod\n def export_max_all_numeric_types(): # type: () -> None\n for op_dtype in all_numeric_dtypes:\n data_0 = np.array([3, 2, 1]).astype(op_dtype)\n data_1 = np.array([1, 4, 4]).astype(op_dtype)\n result = np.array([3, 4, 4]).astype(op_dtype)\n node = onnx.helper.make_node(\n 'Max',\n inputs=['data_0', 'data_1'],\n outputs=['result'],\n )\n expect(node, inputs=[data_0, data_1], outputs=[result],\n name='test_max_{0}'.format(np.dtype(op_dtype).name))\n"
] | [
[
"numpy.array",
"numpy.random.randn",
"numpy.random.rand",
"numpy.sqrt"
],
[
"numpy.random.seed"
],
[
"numpy.array",
"numpy.isnan"
],
[
"numpy.array",
"numpy.dtype",
"numpy.maximum"
]
] |
nghitrampham/air_pollution_death_rate_related | [
"3fd72b9684e8362de5706ba37c1d90b844d4afe0"
] | [
"air_pollution_death_rate_related/scripts/air_pollution/predict_aqi.py"
] | [
"\"\"\"\nThis module is used to predict the Air Quality Index model for 2019 for all counties.\n\"\"\"\nimport pickle\nimport warnings\n\nimport pandas as pd\nimport numpy as np\nfrom keras.models import load_model\n\nimport helpers\n\nwarnings.filterwarnings(\"ignore\")\n\ndef main():\n\n data2019_raw = pd.read_csv(\"\"\"air_pollution_death_rate_related/data/air_pollution/\n data_air_raw/daily_aqi_by_county_2019.csv\"\"\")\n data2019 = helpers.data_cleaning(data2019_raw)\n predicted_date = \"2019-03-12\"\n\n file = open(\"temp.csv\", \"w\")\n file.write(\"date,state_county,AQI\\n\")\n\n # for county in list(data2019[\"state_county\"].unique()):\n for county in list(data2019[\"state_county\"].unique())[:5]:\n\n ## load model to predict AQI\n print(\"---> Loading model for county {} ...\".format(county))\n\n try:\n scaler_path = (\"air_pollution_death_rate_related/trained_model/min_scaler_model/\" +\n county + \"_scaler.pickle\")\n\n model_path = (\"air_pollution_death_rate_related/trained_model/county_aqi/\" +\n county + \"_model.h5\")\n\n model = load_model(model_path)\n mm_scaler = pickle.load(open(scaler_path, \"rb\"))\n\n ### feature engineering for model\n data_feature_temp = helpers.data_feature_engineering_for_test(\n data2019,\n county,\n predicted_date)\n x_test, y_test = helpers.load_test_data(data_feature_temp[\"data\"], mm_scaler)\n\n ## predicting AQI\n predictions = helpers.predict_point_by_point(model, x_test)\n # helpers.plot_results(predictions, y_test)\n\n ## keep prediction for all counties\n print(\"Predicting ....\")\n y_pred = np.append(x_test, predictions.reshape(1, 1, 1)).reshape(1, 39)\n y_scale = mm_scaler.inverse_transform(y_pred)[-1][-1]\n\n file.write(predicted_date+\",\"+county+\",\"+str(y_scale)+\"\\n\")\n\n del data_feature_temp, scaler_path,\\\n model_path, model, mm_scaler, x_test, y_test, predictions, y_pred, y_scale\n\n except Exception as exp:\n print(exp)\n exp.args += ('Path and list_year must not be empty', \"check read_raw_data function\")\n\n file.close()\n\n ## creating dataframe containing county, state, predicted AQI,\n ## predicted date for interactive visualization map\n county_code = pd.read_csv(\"\"\"air_pollution_death_rate_related/data/air_pollution/\n data_misc/county_with_code.csv\"\"\")\n df_prediction = pd.read_csv(\"temp.csv\")\n\n df_result = (pd.merge(county_code, df_prediction,\n how='inner',\n left_on=[\"state_county\"],\n right_on=[\"state_county\"])\n )\n df_result.to_csv(\"predicted_AQI\" + predicted_date + \".csv\", index=False)\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"pandas.read_csv",
"pandas.merge"
]
] |
positivevaib/semi-supervised-imagenet-classification | [
"4fb6427f5a72951c1b866a1ddbc2599811bb5770"
] | [
"deep-clustering-conv-autoencoder/main.py"
] | [
"# import\nimport numpy as np\nimport sklearn as skl\nimport sklearn.cluster as cluster\nimport sklearn.metrics as metrics\nimport torch\nimport torch.distributions.kl as kl\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nimport torch.utils.data as data\nimport torchvision\nimport torchvision.datasets as datasets\nimport torchvision.transforms as transforms\nimport tqdm\n\n\n# model\nclass CAE_ENC(nn.Module):\n def __init__(self):\n super().__init__()\n # self.enc = nn.Sequential(*list(model.features.children())[:-5])\n self.conv1 = nn.Conv2d(3, 32, kernel_size=5, padding=2, stride=2)\n self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1, stride=2)\n self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1, stride=2)\n self.conv4 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)\n self.fc1 = nn.Linear(256 * 6 * 6, 1000)\n\n def forward(self, x):\n # x = self.features(x)\n x = F.relu(self.conv1(x))\n x = F.relu(self.conv2(x))\n x = F.relu(self.conv3(x))\n x = F.relu(self.conv4(x))\n x = x.view(-1, 256 * 6 * 6)\n x = self.fc1(x)\n return x\n\n\nclass CAE_DEC(nn.Module):\n def __init__(self):\n super().__init__()\n self.fc2 = nn.Linear(1000, 256 * 6 * 6)\n self.deconv1 = nn.ConvTranspose2d(256, 128, 2, stride=2)\n self.deconv2 = nn.ConvTranspose2d(128, 64, 2, stride=2)\n self.deconv3 = nn.ConvTranspose2d(64, 32, 2, stride=2)\n self.deconv4 = nn.ConvTranspose2d(32, 3, 2, stride=2)\n self.conv5 = nn.Conv2d(3, 3, kernel_size=1) # might have to remove\n\n def forward(self, x):\n x = F.relu(self.fc2(x))\n x = x.view(128, 256, 6, 6)\n x = F.relu(self.deconv1(x))\n x = F.relu(self.deconv2(x))\n x = F.relu(self.deconv3(x))\n x = F.relu(self.deconv4(x))\n x = torch.sigmoid(self.conv5(x)) # might have to remove\n return x\n\n\nclass ClusteringLayer(nn.Module):\n def __init__(self, weights=None, alpha=1.0):\n super().__init__()\n if weights:\n self.weights = weights\n else:\n self.weights = torch.empty(1000, 1000)\n nn.init.xavier_uniform_(self.weights)\n self.alpha = alpha\n\n def forward(self, x):\n q = 1.0 / (1.0 + (torch.sum(\n (x.unsqueeze(1) - self.weights)**2, dim=2) / self.alpha))\n q **= (self.alpha + 1.0) / 2.0\n q = torch.transpose(\n torch.transpose(q, 1, 2) / torch.sum(q, dim=1), 1, 2)\n return q\n\n\ndef set_weights(module, weights):\n if isinstance(module, ClusteringLayer):\n module.weights = weights\n\n\nclass CAE(nn.Module):\n def __init__(self):\n super().__init__()\n self.enc = CAE_ENC()\n self.dec = CAE_DEC()\n self.clus = ClusteringLayer()\n\n def forward(self, x):\n h = self.enc(x)\n q = self.clus(h)\n o = self.dec(h)\n return (h, q, o)\n\n\ndef loss(q, p, o, gamma=0.1):\n mse = nn.MSELoss(o)\n kld = gamma * kl.kl_divergence(p, q)\n l = mse + kld\n return l\n\n\ndef target_distribution(q):\n weight = q**2 / torch.sum(q, dim=0)\n return torch.transpose(torch.transpose(q) / torch.sum(weight, dim=1))\n\n\n# data\ntransformations = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225),\n inplace=True)\n])\ndataset1 = datasets.ImageFolder('/beegfs/vag273/ssl_data_96/supervised/train/',\n transform=transformations)\ndataset2 = datasets.ImageFolder('/beegfs/vag273/ssl_data_96/unsupervised/',\n transform=transformations)\ndataset = data.ConcatDataset((dataset1, dataset2))\n\ntrain_ratio = 0.9\ntrain_set_size = int(train_ratio * len(dataset))\nval_set_size = len(dataset) - train_set_size\n\ntrain_data, val_data = data.random_split(dataset,\n (train_set_size, val_set_size))\n\ntrain_loader = data.DataLoader(train_data, batch_size=128, shuffle=True)\nval_loader = data.DataLoader(val_data, batch_size=128, shuffle=False)\n\n# training\ndevice = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n\nmodel = CAE().to(device)\n# criterion = nn.MSELoss()\noptimizer = optim.Adam(model.parameters())\n\n# pretrain\nbest_val_loss = float('inf')\ntot_epochs = 200 # maybe lower it on one of the runs\nprint('pretrain')\nfor epoch in range(tot_epochs):\n model.train()\n\n print('epoch {} of {}'.format(epoch + 1, tot_epochs))\n\n desc = \"ITERATION - loss: {:.2f}\"\n pbar = tqdm.tqdm(desc=desc.format(0),\n total=len(train_loader),\n leave=False,\n file=None,\n initial=0)\n\n running_loss = 0\n for batch_idx, data in enumerate(train_loader):\n img, _ = data\n img = img.to(device)\n\n optimizer.zero_grad()\n\n _, _, out = model(img)\n loss = nn.MSELoss(out, img)\n\n running_loss += loss.item()\n\n loss.backward()\n optimizer.step()\n\n pbar.desc = desc.format(loss.item())\n pbar.update()\n\n print('loss: {}'.format(running_loss / len(train_loader)))\n\n model.eval()\n with torch.no_grad():\n val_running_loss = 0\n for val_batch_idx, val_data in enumerate(val_loader):\n val_img, _ = val_data\n val_img = val_img.to(device)\n\n _, _, val_out = model(val_img)\n val_loss = nn.MSELoss(val_out, val_img)\n\n val_running_loss += val_loss.item()\n\n if val_running_loss / len(val_loader) < best_val_loss:\n torch.save(model.state_dict(), 'weights.pth')\n\n print('val loss: {}'.format(val_running_loss / len(val_loader)))\n\n pbar.close()\n\n# first cluster\nfeatures = None\nfor batch_idx, data in enumerate(train_loader):\n img, _ = data\n img = img.to(device)\n\n if not features:\n features = model(img)\n else:\n torch.cat((features, model(img)), 0)\n\nkmeans = cluster.kMeans(n_clusters=1000, n_init=20)\nfeatures = features.view(-1)\npred_last = kmeans.fit_predict(features)\nq = kmeans.cluster_centers_\n\n# deep cluster\nprint('deep cklustering')\nupdate_interval = 140 # maybe reduce this for sake of time\nmaxiter = 20000 # maybe reduce this for sake of time\nfor ite in range(int(maxiter)):\n model.train()\n if ite % update_interval == 0:\n q = None\n for batch_idx, data in enumerate(train_loader):\n img, _ = data\n img = img.to(device)\n\n if not features:\n _, q, _ = model(img)\n else:\n _, new_q, _ = model(img)\n torch.cat((q, new_q), 0)\n p = target_distribution(\n q) # update the auxiliary target distribution p\n\n # evaluate the clustering performance\n pred = q.argmax(1)\n\n # check stop criterion\n delta_label = np.sum(pred != pred_last).astype(\n np.float32) / pred.shape[0]\n pred_last = np.copy(pred)\n if ite > 0 and delta_label < 0.001: # 0.001 is the tolerance\n print('delta_label ', delta_label, '< tol ', 0.001) # tol\n print('Reached tolerance threshold. Stopping training.')\n break\n\n print('epoch {} of {}'.format(epoch + 1, tot_epochs))\n\n desc = \"ITERATION - loss: {:.2f}\"\n pbar = tqdm.tqdm(desc=desc.format(0),\n total=len(train_loader),\n leave=False,\n file=None,\n initial=0)\n\n running_loss = 0\n for batch_idx, data in enumerate(train_loader):\n img, _ = data\n img = img.to(device)\n\n optimizer.zero_grad()\n\n _, q, out = model(img)\n loss = loss(q,\n p[batch_idx * 128:batch_idx * 128 + 128, :],\n out,\n gamma=0.1)\n\n running_loss += loss.item()\n\n loss.backward()\n optimizer.step()\n\n pbar.desc = desc.format(loss.item())\n pbar.update()\n\n print('loss: {}'.format(running_loss / len(train_loader)))\n\n model.eval()\n with torch.no_grad():\n val_running_loss = 0\n for val_batch_idx, val_data in enumerate(val_loader):\n val_img, _ = val_data\n val_img = val_img.to(device)\n\n _, val_q, val_out = model(val_img)\n val_loss = loss(val_q,\n p[val_batch_idx * 128:val_batch_idx * 128 +\n 128, :],\n val_out,\n gamma=0.1)\n\n val_running_loss += val_loss.item()\n\n if val_running_loss / len(val_loader) < best_val_loss:\n torch.save(model.state_dict(), 'overall_weights.pth')\n\n print('val loss: {}'.format(val_running_loss / len(val_loader)))\n\n pbar.close()\n"
] | [
[
"torch.utils.data.ConcatDataset",
"torch.nn.Linear",
"torch.cat",
"torch.nn.MSELoss",
"sklearn.cluster.kMeans",
"numpy.sum",
"torch.utils.data.random_split",
"torch.nn.ConvTranspose2d",
"torch.no_grad",
"numpy.copy",
"torch.nn.init.xavier_uniform_",
"torch.distributions.kl.kl_divergence",
"torch.nn.Conv2d",
"torch.cuda.is_available",
"torch.utils.data.DataLoader",
"torch.transpose",
"torch.empty",
"torch.sum"
]
] |
yhl111/PCNN | [
"2e0967aec962d55df1eb7d149a44b91c6c751a1a"
] | [
"model/config.py"
] | [
"import os\nimport numpy as np\n\nfrom .general_utils import get_logger\nfrom .data_utils import load_vocab, get_processing_word\n\nclass Config():\n def __init__(self, load=True):\n \"\"\"Initialize hyperparameters and load vocabs\n\n Args:\n load_embeddings: (bool) if True, load embeddings into\n np array, else None\n\n \"\"\"\n # directory for training outputs\n if not os.path.exists(self.dir_output):\n os.makedirs(self.dir_output)\n\n # create instance of logger\n self.logger = get_logger(self.path_log)\n\n # load if requested (default)\n if load:\n self.load()\n\n\n def load(self):\n \"\"\"Loads vocabulary, processing functions and embeddings\n\n Supposes that build_data.py has been run successfully and that\n the corresponding files have been created (vocab and trimmed\n vectors)\n\n \"\"\"\n # 1. vocabulary\n self.vocab_words = load_vocab(self.filename_words)\n self.vocab_relations = load_vocab(self.filename_relation)\n\n self.nwords = len(self.vocab_words)\n self.nrelations = len(self.vocab_relations)\n\n # 2. get processing functions that map str -> id\n self.processing_word = get_processing_word(self.vocab_words, UNK = \"<UNK>\")\n self.processing_relation = get_processing_word(self.vocab_relations, UNK='NA')\n\n # 3. get pre-trained embeddings\n self.embeddings = (np.load(self.filename_embeddings)['vec']\n if self.use_pretrained else None)\n\n\n # general config\n dir_output = \"./results/test/\"\n graph_output = \"./graph\"\n dir_model = dir_output + \"model.weights/\" # directory to save models\n path_log = dir_output + \"log.txt\"\n restore_model = \"./results/test/model.weights/early_best.ckpt\"\n\n # embeddings\n dim_word = 50\n dim_pos = 5\n dim = dim_word + 2*dim_pos\n\n # position range in sentence\n nposition = 500\n\n # convolution\n window_size = 3\n feature_maps = 230\n\n filename_train_origin = \"./data/origin_data/train.txt\"\n filename_train = \"./data/processed_data/train.txt\"\n filename_train_wrong = \"./data/processed_data/wrong_parse_train.txt\"\n\n filename_dev = \"./data/processed_data/test.txt\"\n\n filename_test_origin = \"./data/origin_data/test.txt\"\n filename_test = \"./data/processed_data/test.txt\"\n filename_test_wrong = \"./data/processed_data/wrong_parse_test.txt\"\n\n max_iter = None # if not None, max number of examples in Dataset\n\n # vocab (created from dataset with build_data.py)\n filename_words = \"./data/processed_data/words.txt\"\n filename_embeddings = \"./data/processed_data/vectors.npz\"\n\n filename_relation_origin = \"./data/origin_data/relation2id.txt\"\n filename_relation = \"./data/processed_data/relation.txt\"\n\n # word vectors file\n filename_wordvectors = \"./data/origin_data/vec.txt\"\n\n use_pretrained = True\n\n MIL = False # if True, using multi-instances learning\n shuffle = False # if True, shuffle train dataset\n max_iter = None # if not None, max number of examples in Dataset\n\n # training\n train_word_embeddings = False\n train_pos_embeddings = True\n nepochs = 15\n dropout = 0.5\n batch_size = 50\n lr_method = \"adadelta\"\n lr = 0.001\n lr_decay = 0.9\n clip = -1 # if negative, no clipping\n nepoch_no_imprv = 3\n early_stop = True\n max_train_step = 100000\n"
] | [
[
"numpy.load"
]
] |
thompson318/scikit-surgerycore | [
"22867073a5a3e87def68b4a76e70fe54d085be32"
] | [
"tests/algorithms/test_tracking_smoothing.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"Tests for BARD pointer module\"\"\"\nimport math\nimport numpy as np\nimport pytest\nimport sksurgerycore.algorithms.tracking_smoothing as reg\n\n\ndef test_rvec_to_quaterion():\n \"\"\"\n Does it convert correctly\n \"\"\"\n\n #a 90 degree rotation about the x axis\n rvec = np.array([math.pi/2.0, 0.0, 0.0])\n\n quaternion = reg._rvec_to_quaternion(rvec) # pylint: disable=protected-access\n\n assert quaternion[0] == math.cos(math.pi/4.0)\n assert quaternion[1] == 1.0 * math.sin(math.pi/4.0)\n assert quaternion[2] == 0.0\n assert quaternion[3] == 0.0\n\n\ndef test_quaterion_to_matrix():\n \"\"\"\n Test conversion on a 90 degree rotation about y axis.\n \"\"\"\n quaternion = np.array([math.cos(math.pi/4.0), 0.0,\n 1.0 * math.sin(math.pi/4.0), 0.0])\n\n rot_mat = reg.quaternion_to_matrix(quaternion)\n\n rot_mat1 = np.eye(3, dtype=np.float64)\n\n rot_mat1[0, 0] = 0.0\n rot_mat1[0, 2] = 1.0\n rot_mat1[2, 0] = -1.0\n rot_mat1[2, 2] = 0.0\n\n assert np.allclose(rot_mat, rot_mat1, rtol=1e-05, atol=1e-10)\n\ndef test_rolling_mean_no_buffer():\n \"\"\"\n Try doing a rolling mean with zero buffer.\n \"\"\"\n with pytest.raises(ValueError):\n _ = reg.RollingMean(vector_size=3, buffer_size=0)\n\n\n\ndef test_rolling_mean_returns_nan():\n \"\"\"\n Tests for rolling mean class.\n \"\"\"\n\n mean_buffer = reg.RollingMean(vector_size=3, buffer_size=5)\n\n assert np.isnan(mean_buffer.getmean()).all\n\ndef test_rolling_mean_single_value():\n \"\"\"\n Test rolling mean returns vector value for single entry\n \"\"\"\n vector = [5.4, 1.2, 3.4]\n\n mean_buffer = reg.RollingMean(vector_size=3, buffer_size=5)\n\n mean_buffer.pop(vector)\n\n assert np.allclose(vector, mean_buffer.getmean(), rtol=1e-05, atol=1e-10)\n\ndef test_rolling_mean_four_values():\n \"\"\"\n Test rolling mean returns vector value for single entry\n \"\"\"\n vector0 = [5.4, 1.2, 3.4]\n vector1 = [7.4, -1.2, -1.4]\n vector2 = [-2.6, 4.2, 2.6]\n vector3 = [9.0, 3.3, 3.6]\n\n expected_answer0 = [3.4, 1.4, 1.533333]\n expected_answer1 = [4.6, 2.1, 1.6]\n\n mean_buffer = reg.RollingMean(vector_size=3, buffer_size=3)\n mean_buffer.pop(vector0)\n mean_buffer.pop(vector1)\n mean_buffer.pop(vector2)\n assert np.allclose(expected_answer0, mean_buffer.getmean(), rtol=1e-05,\n atol=1e-6)\n\n mean_buffer.pop(vector3)\n\n assert np.allclose(expected_answer1, mean_buffer.getmean(), rtol=1e-05,\n atol=1e-10)\n\n\ndef test_rolling_rotation_no_buffer():\n \"\"\"\n Try doing a rolling rotation mean with zero buffer.\n \"\"\"\n with pytest.raises(ValueError):\n _ = reg.RollingMeanRotation(buffer_size=0)\n\n\ndef test_rolling_rot_returns_nan():\n \"\"\"\n Tests for rolling mean rotation class.\n \"\"\"\n\n mean_buffer = reg.RollingMeanRotation(buffer_size=5)\n\n assert np.isnan(mean_buffer.getmean()).all\n\n\ndef test_rolling_rot_single_value():\n \"\"\"\n Test rolling mean rotation returns vector value for single entry\n \"\"\"\n\n rvec = np.array([0.0, -math.pi/2.0, 0.0])\n expected_quaternion = np.array([math.cos(math.pi/4.0), 0.0,\n -1.0 * math.sin(math.pi/4.0), 0.0])\n\n mean_buffer = reg.RollingMeanRotation(buffer_size=5)\n\n mean_buffer.pop(rvec)\n\n assert np.allclose(expected_quaternion, mean_buffer.getmean(),\n rtol=1e-05, atol=1e-10)\n\n\ndef test_r_rot_sgl_value_sgl_buff():\n \"\"\"\n Test rolling mean rotation returns vector value for single entry\n \"\"\"\n\n rvec = np.array([0.0, 0.0, -math.pi/2.0])\n expected_quaternion = np.array([math.cos(math.pi/4.0), 0.0, 0.0,\n -1.0 * math.sin(math.pi/4.0)])\n\n mean_buffer = reg.RollingMeanRotation(buffer_size=1)\n\n mean_buffer.pop(rvec)\n\n assert np.allclose(expected_quaternion, mean_buffer.getmean(),\n rtol=1e-05, atol=1e-10)\n\n\ndef test_rolling_rot_four_values():\n \"\"\"\n Test rolling mean returns vector value for single entry\n \"\"\"\n rvec0 = [0.0, 0.0, 0.0]\n rvec1 = [np.NaN, np.NaN, np.NaN]\n rvec2 = [0.0, 0.0, -math.pi/2.0]\n rvec3 = [0.0, math.pi/3.0, 0.0]\n\n expected_answer0 = reg._rvec_to_quaternion([0.0, 0.0, -math.pi/4.0]) # pylint: disable=protected-access\n #the next ones more of a regression test, I haven't independently\n #calculated this answer.\n expected_answer1 = [-0.87602709, 0.0, -0.27843404, 0.39376519]\n\n mean_buffer = reg.RollingMeanRotation(buffer_size=3)\n mean_buffer.pop(rvec0)\n mean_buffer.pop(rvec1)\n mean_buffer.pop(rvec2)\n assert np.allclose(expected_answer0, mean_buffer.getmean(), rtol=1e-05,\n atol=1e-6)\n\n mean_buffer.pop(rvec3)\n\n assert np.allclose(expected_answer1, mean_buffer.getmean(), rtol=1e-05,\n atol=1e-10)\n"
] | [
[
"numpy.allclose",
"numpy.array",
"numpy.eye"
]
] |
bourov/probability | [
"1e4053a0938b4773c3425bcbb07b3f1e5d50c7e2",
"1e4053a0938b4773c3425bcbb07b3f1e5d50c7e2",
"1e4053a0938b4773c3425bcbb07b3f1e5d50c7e2",
"1e4053a0938b4773c3425bcbb07b3f1e5d50c7e2",
"1e4053a0938b4773c3425bcbb07b3f1e5d50c7e2",
"1e4053a0938b4773c3425bcbb07b3f1e5d50c7e2",
"1e4053a0938b4773c3425bcbb07b3f1e5d50c7e2",
"1e4053a0938b4773c3425bcbb07b3f1e5d50c7e2",
"1e4053a0938b4773c3425bcbb07b3f1e5d50c7e2"
] | [
"tensorflow_probability/python/distributions/deterministic.py",
"tensorflow_probability/python/internal/backend/numpy/debugging.py",
"tensorflow_probability/python/internal/backend/numpy/gen/linear_operator_diag.py",
"tensorflow_probability/examples/grammar_vae.py",
"tensorflow_probability/python/distributions/sample_test.py",
"tensorflow_probability/python/experimental/nn/variational_base.py",
"tensorflow_probability/python/mcmc/replica_exchange_mc_test.py",
"tensorflow_probability/python/sts/local_linear_trend_test.py",
"tensorflow_probability/python/experimental/edward2/random_variable_test.py"
] | [
"# Copyright 2018 The TensorFlow Probability 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\"\"\"The Deterministic distribution class.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport abc\n\n# Dependency imports\nimport six\nimport tensorflow.compat.v2 as tf\n\nfrom tensorflow_probability.python.distributions import distribution\nfrom tensorflow_probability.python.distributions import kullback_leibler\nfrom tensorflow_probability.python.internal import assert_util\nfrom tensorflow_probability.python.internal import dtype_util\nfrom tensorflow_probability.python.internal import reparameterization\nfrom tensorflow_probability.python.internal import tensor_util\nfrom tensorflow_probability.python.internal import tensorshape_util\n\n__all__ = [\n 'Deterministic',\n 'VectorDeterministic',\n]\n\n\[email protected]_metaclass(abc.ABCMeta)\nclass _BaseDeterministic(distribution.Distribution):\n \"\"\"Base class for Deterministic distributions.\"\"\"\n\n def __init__(self,\n loc,\n atol=None,\n rtol=None,\n is_vector=False,\n validate_args=False,\n allow_nan_stats=True,\n parameters=None,\n name='_BaseDeterministic'):\n \"\"\"Initialize a batch of `_BaseDeterministic` distributions.\n\n The `atol` and `rtol` parameters allow for some slack in `pmf`, `cdf`\n computations, e.g. due to floating-point error.\n\n ```\n pmf(x; loc)\n = 1, if Abs(x - loc) <= atol + rtol * Abs(loc),\n = 0, otherwise.\n ```\n\n Args:\n loc: Numeric `Tensor`. The point (or batch of points) on which this\n distribution is supported.\n atol: Non-negative `Tensor` of same `dtype` as `loc` and broadcastable\n shape. The absolute tolerance for comparing closeness to `loc`.\n Default is `0`.\n rtol: Non-negative `Tensor` of same `dtype` as `loc` and broadcastable\n shape. The relative tolerance for comparing closeness to `loc`.\n Default is `0`.\n is_vector: Python `bool`. If `True`, this is for `VectorDeterministic`,\n else `Deterministic`.\n validate_args: Python `bool`, default `False`. When `True` distribution\n parameters are checked for validity despite possibly degrading runtime\n performance. When `False` invalid inputs may silently render incorrect\n outputs.\n allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n (e.g., mean, mode, variance) use the value '`NaN`' to indicate the\n result is undefined. When `False`, an exception is raised if one or\n more of the statistic's batch members are undefined.\n parameters: Dict of locals to facilitate copy construction.\n name: Python `str` name prefixed to Ops created by this class.\n\n Raises:\n ValueError: If `loc` is a scalar.\n \"\"\"\n with tf.name_scope(name) as name:\n dtype = dtype_util.common_dtype([loc, atol, rtol], dtype_hint=tf.float32)\n self._loc = tensor_util.convert_nonref_to_tensor(\n loc, dtype_hint=dtype, name='loc')\n self._atol = tensor_util.convert_nonref_to_tensor(\n 0 if atol is None else atol, dtype=dtype, name='atol')\n self._rtol = tensor_util.convert_nonref_to_tensor(\n 0 if rtol is None else rtol, dtype=dtype, name='rtol')\n self._is_vector = is_vector\n\n super(_BaseDeterministic, self).__init__(\n dtype=self._loc.dtype,\n reparameterization_type=(\n reparameterization.FULLY_REPARAMETERIZED\n if dtype_util.is_floating(self._loc.dtype)\n else reparameterization.NOT_REPARAMETERIZED),\n validate_args=validate_args,\n allow_nan_stats=allow_nan_stats,\n parameters=parameters,\n name=name)\n\n def _slack(self, loc):\n # Avoid using the large broadcast with self.loc if possible.\n if self.parameters['rtol'] is None:\n return self.atol\n else:\n return self.atol + self.rtol * tf.abs(loc)\n\n @property\n def loc(self):\n \"\"\"Point (or batch of points) at which this distribution is supported.\"\"\"\n return self._loc\n\n @property\n def atol(self):\n \"\"\"Absolute tolerance for comparing points to `self.loc`.\"\"\"\n return self._atol\n\n @property\n def rtol(self):\n \"\"\"Relative tolerance for comparing points to `self.loc`.\"\"\"\n return self._rtol\n\n def _entropy(self):\n return tf.zeros(self.batch_shape_tensor(), dtype=self.dtype)\n\n def _mean(self):\n return tf.identity(self.loc)\n\n def _variance(self):\n return tf.zeros_like(self.loc)\n\n def _mode(self):\n return self.mean()\n\n def _sample_n(self, n, seed=None):\n del seed # unused\n loc = tf.convert_to_tensor(self.loc)\n return tf.broadcast_to(\n loc,\n tf.concat([[n], self._batch_shape_tensor(loc=loc),\n self._event_shape_tensor(loc=loc)],\n axis=0))\n\n def _default_event_space_bijector(self):\n return\n\n def _parameter_control_dependencies(self, is_init):\n assertions = []\n\n # In init, we can always build shape and dtype checks because\n # we assume shape doesn't change for Variable backed args.\n if is_init and self._is_vector:\n msg = 'Argument `loc` must be at least rank 1.'\n if tensorshape_util.rank(self.loc.shape) is not None:\n if tensorshape_util.rank(self.loc.shape) < 1:\n raise ValueError(msg)\n elif self.validate_args:\n assertions.append(\n assert_util.assert_rank_at_least(self.loc, 1, message=msg))\n\n if not self.validate_args:\n assert not assertions # Should never happen\n return []\n\n if is_init != tensor_util.is_ref(self.atol):\n assertions.append(\n assert_util.assert_non_negative(\n self.atol, message='Argument \"atol\" must be non-negative'))\n if is_init != tensor_util.is_ref(self.rtol):\n assertions.append(\n assert_util.assert_non_negative(\n self.rtol, message='Argument \"rtol\" must be non-negative'))\n return assertions\n\n\nclass Deterministic(_BaseDeterministic):\n \"\"\"Scalar `Deterministic` distribution on the real line.\n\n The scalar `Deterministic` distribution is parameterized by a [batch] point\n `loc` on the real line. The distribution is supported at this point only,\n and corresponds to a random variable that is constant, equal to `loc`.\n\n See [Degenerate rv](https://en.wikipedia.org/wiki/Degenerate_distribution).\n\n #### Mathematical Details\n\n The probability mass function (pmf) and cumulative distribution function (cdf)\n are\n\n ```none\n pmf(x; loc) = 1, if x == loc, else 0\n cdf(x; loc) = 1, if x >= loc, else 0\n ```\n\n #### Examples\n\n ```python\n # Initialize a single Deterministic supported at zero.\n constant = tfp.distributions.Deterministic(0.)\n constant.prob(0.)\n ==> 1.\n constant.prob(2.)\n ==> 0.\n\n # Initialize a [2, 2] batch of scalar constants.\n loc = [[0., 1.], [2., 3.]]\n x = [[0., 1.1], [1.99, 3.]]\n constant = tfp.distributions.Deterministic(loc)\n constant.prob(x)\n ==> [[1., 0.], [0., 1.]]\n ```\n\n \"\"\"\n\n def __init__(self,\n loc,\n atol=None,\n rtol=None,\n validate_args=False,\n allow_nan_stats=True,\n name='Deterministic'):\n \"\"\"Initialize a scalar `Deterministic` distribution.\n\n The `atol` and `rtol` parameters allow for some slack in `pmf`, `cdf`\n computations, e.g. due to floating-point error.\n\n ```\n pmf(x; loc)\n = 1, if Abs(x - loc) <= atol + rtol * Abs(loc),\n = 0, otherwise.\n ```\n\n Args:\n loc: Numeric `Tensor` of shape `[B1, ..., Bb]`, with `b >= 0`.\n The point (or batch of points) on which this distribution is supported.\n atol: Non-negative `Tensor` of same `dtype` as `loc` and broadcastable\n shape. The absolute tolerance for comparing closeness to `loc`.\n Default is `0`.\n rtol: Non-negative `Tensor` of same `dtype` as `loc` and broadcastable\n shape. The relative tolerance for comparing closeness to `loc`.\n Default is `0`.\n validate_args: Python `bool`, default `False`. When `True` distribution\n parameters are checked for validity despite possibly degrading runtime\n performance. When `False` invalid inputs may silently render incorrect\n outputs.\n allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n (e.g., mean, mode, variance) use the value '`NaN`' to indicate the\n result is undefined. When `False`, an exception is raised if one or\n more of the statistic's batch members are undefined.\n name: Python `str` name prefixed to Ops created by this class.\n \"\"\"\n parameters = dict(locals())\n super(Deterministic, self).__init__(\n loc,\n atol=atol,\n rtol=rtol,\n validate_args=validate_args,\n allow_nan_stats=allow_nan_stats,\n parameters=parameters,\n name=name)\n\n @classmethod\n def _params_event_ndims(cls):\n return dict(loc=0, atol=0, rtol=0)\n\n def _batch_shape_tensor(self, loc=None):\n return tf.broadcast_dynamic_shape(\n tf.shape(self.loc if loc is None else loc),\n tf.broadcast_dynamic_shape(tf.shape(self.atol), tf.shape(self.rtol)))\n\n def _batch_shape(self):\n return tf.broadcast_static_shape(\n self.loc.shape,\n tf.broadcast_static_shape(self.atol.shape, self.rtol.shape))\n\n def _event_shape_tensor(self, loc=None):\n del loc\n return tf.constant([], dtype=tf.int32)\n\n def _event_shape(self):\n return tf.TensorShape([])\n\n def _prob(self, x):\n loc = tf.convert_to_tensor(self.loc)\n # Enforces dtype of probability to be float, when self.dtype is not.\n prob_dtype = self.dtype if dtype_util.is_floating(\n self.dtype) else tf.float32\n return tf.cast(tf.abs(x - loc) <= self._slack(loc), dtype=prob_dtype)\n\n def _cdf(self, x):\n loc = tf.identity(self.loc)\n return tf.cast(x >= loc - self._slack(loc), dtype=self.dtype)\n\n\nclass VectorDeterministic(_BaseDeterministic):\n \"\"\"Vector `Deterministic` distribution on `R^k`.\n\n The `VectorDeterministic` distribution is parameterized by a [batch] point\n `loc in R^k`. The distribution is supported at this point only,\n and corresponds to a random variable that is constant, equal to `loc`.\n\n See [Degenerate rv](https://en.wikipedia.org/wiki/Degenerate_distribution).\n\n #### Mathematical Details\n\n The probability mass function (pmf) is\n\n ```none\n pmf(x; loc)\n = 1, if All[Abs(x - loc) <= atol + rtol * Abs(loc)],\n = 0, otherwise.\n ```\n\n #### Examples\n\n ```python\n tfd = tfp.distributions\n\n # Initialize a single VectorDeterministic supported at [0., 2.] in R^2.\n constant = tfd.Deterministic([0., 2.])\n constant.prob([0., 2.])\n ==> 1.\n constant.prob([0., 3.])\n ==> 0.\n\n # Initialize a [3] batch of constants on R^2.\n loc = [[0., 1.], [2., 3.], [4., 5.]]\n constant = tfd.VectorDeterministic(loc)\n constant.prob([[0., 1.], [1.9, 3.], [3.99, 5.]])\n ==> [1., 0., 0.]\n ```\n\n \"\"\"\n\n def __init__(self,\n loc,\n atol=None,\n rtol=None,\n validate_args=False,\n allow_nan_stats=True,\n name='VectorDeterministic'):\n \"\"\"Initialize a `VectorDeterministic` distribution on `R^k`, for `k >= 0`.\n\n Note that there is only one point in `R^0`, the 'point' `[]`. So if `k = 0`\n then `self.prob([]) == 1`.\n\n The `atol` and `rtol` parameters allow for some slack in `pmf`\n computations, e.g. due to floating-point error.\n\n ```\n pmf(x; loc)\n = 1, if All[Abs(x - loc) <= atol + rtol * Abs(loc)],\n = 0, otherwise\n ```\n\n Args:\n loc: Numeric `Tensor` of shape `[B1, ..., Bb, k]`, with `b >= 0`, `k >= 0`\n The point (or batch of points) on which this distribution is supported.\n atol: Non-negative `Tensor` of same `dtype` as `loc` and broadcastable\n shape. The absolute tolerance for comparing closeness to `loc`.\n Default is `0`.\n rtol: Non-negative `Tensor` of same `dtype` as `loc` and broadcastable\n shape. The relative tolerance for comparing closeness to `loc`.\n Default is `0`.\n validate_args: Python `bool`, default `False`. When `True` distribution\n parameters are checked for validity despite possibly degrading runtime\n performance. When `False` invalid inputs may silently render incorrect\n outputs.\n allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n (e.g., mean, mode, variance) use the value '`NaN`' to indicate the\n result is undefined. When `False`, an exception is raised if one or\n more of the statistic's batch members are undefined.\n name: Python `str` name prefixed to Ops created by this class.\n \"\"\"\n parameters = dict(locals())\n super(VectorDeterministic, self).__init__(\n loc,\n atol=atol,\n rtol=rtol,\n is_vector=True,\n validate_args=validate_args,\n allow_nan_stats=allow_nan_stats,\n parameters=parameters,\n name=name)\n\n @classmethod\n def _params_event_ndims(cls):\n return dict(loc=1, atol=1, rtol=1)\n\n def _batch_shape_tensor(self, loc=None):\n return tf.broadcast_dynamic_shape(\n tf.shape(self.loc if loc is None else loc),\n tf.broadcast_dynamic_shape(tf.shape(self.atol),\n tf.shape(self.rtol)))[:-1]\n\n def _batch_shape(self):\n return tf.broadcast_static_shape(\n self.loc.shape,\n tf.broadcast_static_shape(self.atol.shape, self.rtol.shape))[:-1]\n\n def _event_shape_tensor(self, loc=None):\n return tf.shape(self.loc if loc is None else loc)[-1:]\n\n def _event_shape(self):\n return self.loc.shape[-1:]\n\n def _prob(self, x):\n loc = tf.convert_to_tensor(self.loc)\n return tf.cast(\n tf.reduce_all(tf.abs(x - loc) <= self._slack(loc), axis=-1),\n dtype=self.dtype)\n\n def _sample_control_dependencies(self, x):\n assertions = []\n if not self.validate_args:\n return assertions\n assertions.append(assert_util.assert_rank_at_least(x, 1))\n assertions.append(assert_util.assert_equal(\n self.event_shape_tensor(), tf.gather(tf.shape(x), tf.rank(x) - 1),\n message=('Argument `x` not defined in the same space '\n 'R**k as this distribution')))\n return assertions\n\n\n@kullback_leibler.RegisterKL(_BaseDeterministic, distribution.Distribution)\ndef _kl_deterministic_distribution(a, b, name=None):\n \"\"\"Calculate the batched KL divergence `KL(a || b)` with `a` Deterministic.\n\n Args:\n a: instance of a Deterministic distribution object.\n b: instance of a Distribution distribution object.\n name: (optional) Name to use for created operations. Default is\n 'kl_deterministic_distribution'.\n\n Returns:\n Batchwise `KL(a || b)`.\n \"\"\"\n with tf.name_scope(name or 'kl_deterministic_distribution'):\n return -b.log_prob(a.loc)\n",
"# Copyright 2018 The TensorFlow Probability 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\"\"\"Experimental Numpy backend.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nimport six\n\nfrom tensorflow_probability.python.internal.backend.numpy import _utils as utils\nfrom tensorflow_probability.python.internal.backend.numpy.ops import convert_to_tensor\nfrom tensorflow_probability.python.internal.backend.numpy.ops import is_tensor\nfrom tensorflow_probability.python.internal.backend.numpy.ops import Tensor\n\n\n__all__ = [\n 'Assert',\n 'assert_equal',\n 'assert_greater',\n 'assert_greater_equal',\n 'assert_integer',\n 'assert_less',\n 'assert_less_equal',\n 'assert_near',\n 'assert_negative',\n 'assert_non_negative',\n 'assert_non_positive',\n 'assert_none_equal',\n 'assert_positive',\n 'assert_proper_iterable',\n 'assert_rank',\n 'assert_rank_at_least',\n 'assert_rank_in',\n 'assert_scalar',\n 'check_numerics',\n]\n\nJAX_MODE = False\n\n\ndef skip_assert_for_tracers(f):\n \"\"\"Function decorator that returns None if JAX tracers are detected.\"\"\"\n if not JAX_MODE:\n return f\n from jax import core as jax_core # pylint: disable=g-import-not-at-top\n def wrapped(*args, **kwargs):\n if any(isinstance(arg, jax_core.Tracer) for arg\n in args + tuple(kwargs.values())):\n print('skip assert ' + f.__name__)\n return None\n return f(*args, **kwargs)\n return wrapped\n\n\n@skip_assert_for_tracers\ndef _assert_binary(\n x, y, comparator, sym, summarize=None, message=None, name=None):\n del summarize\n del name\n x = convert_to_tensor(x)\n y = convert_to_tensor(y)\n if not np.all(comparator(x, y)):\n raise ValueError('Condition x {} y did not hold element-wise. {}'.format(\n sym, message or ''))\n\n\n@skip_assert_for_tracers\ndef _assert_equal(x, y, summarize=None, message=None, name=None):\n del summarize\n del name\n x = convert_to_tensor(x)\n y = convert_to_tensor(y)\n if not np.all(np.equal(x, y)):\n raise ValueError('Expected x == y but got {} vs {} {}'.format(\n x, y, message or ''))\n\n\ndef _assert_greater(x, y, summarize=None, message=None, name=None):\n return _assert_binary(\n x, y, np.greater, '>', summarize=summarize,\n message=message, name=name)\n\n\ndef _assert_less(x, y, summarize=None, message=None, name=None):\n return _assert_binary(\n x, y, np.less, '<', summarize=summarize,\n message=message, name=name)\n\n\ndef _assert_greater_equal(\n x, y, summarize=None, message=None, name=None):\n return _assert_binary(\n x, y, np.greater_equal, '>=', summarize=summarize,\n message=message, name=name)\n\n\ndef _assert_less_equal(\n x, y, summarize=None, message=None, name=None):\n return _assert_binary(\n x, y, np.less_equal, '<=', summarize=summarize,\n message=message, name=name)\n\n\n@skip_assert_for_tracers\ndef _assert_compare_to_zero(\n x, comparator, sym, summarize=None, message=None, name=None):\n del summarize\n del name\n x = convert_to_tensor(x)\n if not np.all(comparator(x, 0)):\n raise ValueError(\n 'Condition x {} 0 did not hold element-wise; got {} {}'.format(\n sym, x, message or ''))\n\n\ndef _assert_positive(x, summarize=None, message=None, name=None):\n return _assert_compare_to_zero(\n x, np.greater, '>', summarize=summarize, message=message, name=name)\n\n\ndef _assert_negative(x, summarize=None, message=None, name=None):\n return _assert_compare_to_zero(\n x, np.less, '<', summarize=summarize, message=message, name=name)\n\n\ndef _assert_non_negative(x, summarize=None, message=None, name=None):\n return _assert_compare_to_zero(\n x, np.greater_equal, '>=',\n summarize=summarize, message=message, name=name)\n\n\ndef _assert_non_positive(x, summarize=None, message=None, name=None):\n return _assert_compare_to_zero(\n x, np.less_equal, '<=', summarize=summarize, message=message, name=name)\n\n\ndef _assert_rank(x, rank, message=None, name=None): # pylint: disable=unused-argument\n return _assert_equal(x=len(np.shape(x)), y=rank, message=message)\n\n\ndef _assert_scalar(*_, **__): # pylint: disable=unused-argument\n pass\n\n\ndef _assert_integer(*_, **__): # pylint: disable=unused-argument\n pass\n\n\n@skip_assert_for_tracers\ndef _assert_near(x, y, rtol=None, atol=None,\n message=None, summarize=None, name=None): # pylint: disable=unused-argument\n \"\"\"Raises an error if abs(x - y) > atol + rtol * abs(y).\"\"\"\n del summarize\n del name\n x = convert_to_tensor(x)\n y = convert_to_tensor(y)\n rtol = rtol if rtol else 10 * np.finfo(x.dtype).eps\n atol = atol if atol else 10 * np.finfo(x.dtype).eps\n if np.any(np.abs(x - y) > atol + rtol * np.abs(y)):\n raise ValueError('x = {} and y = {} are not equal to tolerance rtol = {}, '\n 'atol = {} {}'.format(x, y, rtol, atol, message or ''))\n\n\n@skip_assert_for_tracers\ndef _assert_none_equal(x, y, summarize=None, message=None, name=None):\n del summarize\n del name\n x = convert_to_tensor(x)\n y = convert_to_tensor(y)\n if np.any(np.equal(x, y)):\n raise ValueError('Expected x != y but got {} vs {} {}'.format(\n x, y, message or ''))\n\n\ndef _assert_proper_iterable(values):\n unintentional_iterables = (Tensor, np.ndarray, bytes, six.text_type)\n if isinstance(values, unintentional_iterables):\n raise TypeError(\n 'Expected argument \"values\" to be a \"proper\" iterable. Found: %s' %\n type(values))\n\n if not hasattr(values, '__iter__'):\n raise TypeError(\n 'Expected argument \"values\" to be iterable. Found: %s' % type(values))\n\n\ndef _assert_rank_at_least(x, rank, message=None, name=None):\n del name\n if len(x.shape) < rank:\n raise ValueError('Expected rank at least {} but got shape {} {}'.format(\n rank, x.shape, message or ''))\n\n\ndef _assert_rank_in(*_, **__): # pylint: disable=unused-argument\n pass\n\n\n# --- Begin Public Functions --------------------------------------------------\n\n\nAssert = utils.copy_docstring( # pylint: disable=invalid-name\n 'tf.debugging.Assert',\n lambda condition, data, summarize=None, name=None: None)\n\nassert_equal = utils.copy_docstring(\n 'tf.debugging.assert_equal',\n _assert_equal)\n\nassert_greater = utils.copy_docstring(\n 'tf.debugging.assert_greater',\n _assert_greater)\n\nassert_less = utils.copy_docstring(\n 'tf.debugging.assert_less',\n _assert_less)\n\nassert_rank = utils.copy_docstring(\n 'tf.debugging.assert_rank',\n _assert_rank)\n\nassert_scalar = utils.copy_docstring(\n 'tf.debugging.assert_scalar',\n _assert_scalar)\n\nassert_greater_equal = utils.copy_docstring(\n 'tf.debugging.assert_greater_equal',\n _assert_greater_equal)\n\nassert_integer = utils.copy_docstring(\n 'tf.debugging.assert_integer',\n _assert_integer)\n\nassert_less_equal = utils.copy_docstring(\n 'tf.debugging.assert_less_equal',\n _assert_less_equal)\n\nassert_near = utils.copy_docstring(\n 'tf.debugging.assert_near',\n _assert_near)\n\nassert_negative = utils.copy_docstring(\n 'tf.debugging.assert_negative',\n _assert_negative)\n\nassert_non_negative = utils.copy_docstring(\n 'tf.debugging.assert_non_negative',\n _assert_non_negative)\n\nassert_non_positive = utils.copy_docstring(\n 'tf.debugging.assert_non_positive',\n _assert_non_positive)\n\nassert_none_equal = utils.copy_docstring(\n 'tf.debugging.assert_none_equal',\n _assert_none_equal)\n\nassert_positive = utils.copy_docstring(\n 'tf.debugging.assert_positive',\n _assert_positive)\n\nassert_proper_iterable = utils.copy_docstring(\n 'tf.debugging.assert_proper_iterable',\n _assert_proper_iterable)\n\nassert_rank_at_least = utils.copy_docstring(\n 'tf.debugging.assert_rank_at_least',\n _assert_rank_at_least)\n\nassert_rank_in = utils.copy_docstring(\n 'tf.debugging.assert_rank_in',\n _assert_rank_in)\n\ncheck_numerics = utils.copy_docstring(\n 'tf.debugging.check_numerics',\n lambda x, *_, **__: x)\n\nis_numeric_tensor = utils.copy_docstring(\n 'tf.debugging.is_numeric_tensor',\n lambda x: is_tensor(x) and np.issubdtype(x.dtype, np.number))\n",
"# Copyright 2020 The TensorFlow Probability Authors. All Rights Reserved.\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# THIS FILE IS AUTO-GENERATED BY `gen_linear_operators.py`.\n# DO NOT MODIFY DIRECTLY.\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# pylint: disable=g-import-not-at-top\n# pylint: disable=g-direct-tensorflow-import\n# pylint: disable=g-bad-import-order\n# pylint: disable=unused-import\n# pylint: disable=line-too-long\n# pylint: disable=reimported\n# pylint: disable=g-bool-id-comparison\n# pylint: disable=g-statement-before-imports\n# pylint: disable=bad-continuation\n# pylint: disable=useless-import-alias\n# pylint: disable=property-with-parameters\n# pylint: disable=trailing-whitespace\n\n# Copyright 2016 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\"\"\"`LinearOperator` acting like a diagonal matrix.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\n# [internal] enable type annotations\nfrom __future__ import print_function\n\nfrom tensorflow_probability.python.internal.backend.numpy import ops\nfrom tensorflow_probability.python.internal.backend.numpy import numpy_array as array_ops\nfrom tensorflow_probability.python.internal.backend.numpy import debugging as check_ops\nfrom tensorflow_probability.python.internal.backend.numpy import numpy_math as math_ops\nfrom tensorflow_probability.python.internal.backend.numpy import linalg_impl as linalg\nfrom tensorflow_probability.python.internal.backend.numpy.gen import linear_operator\nfrom tensorflow_probability.python.internal.backend.numpy.gen import linear_operator_util\n# from tensorflow.python.util.tf_export import tf_export\n\n__all__ = [\"LinearOperatorDiag\",]\n\n\n# @tf_export(\"linalg.LinearOperatorDiag\")\nclass LinearOperatorDiag(linear_operator.LinearOperator):\n \"\"\"`LinearOperator` acting like a [batch] square diagonal matrix.\n\n This operator acts like a [batch] diagonal matrix `A` with shape\n `[B1,...,Bb, N, N]` for some `b >= 0`. The first `b` indices index a\n batch member. For every batch index `(i1,...,ib)`, `A[i1,...,ib, : :]` is\n an `N x N` matrix. This matrix `A` is not materialized, but for\n purposes of broadcasting this shape will be relevant.\n\n `LinearOperatorDiag` is initialized with a (batch) vector.\n\n ```python\n # Create a 2 x 2 diagonal linear operator.\n diag = [1., -1.]\n operator = LinearOperatorDiag(diag)\n\n operator.to_dense()\n ==> [[1., 0.]\n [0., -1.]]\n\n tensor_shape.TensorShape(operator.shape)\n ==> [2, 2]\n\n operator.log_abs_determinant()\n ==> scalar Tensor\n\n x = ... Shape [2, 4] Tensor\n operator.matmul(x)\n ==> Shape [2, 4] Tensor\n\n # Create a [2, 3] batch of 4 x 4 linear operators.\n diag = tf.random.normal(shape=[2, 3, 4])\n operator = LinearOperatorDiag(diag)\n\n # Create a shape [2, 1, 4, 2] vector. Note that this shape is compatible\n # since the batch dimensions, [2, 1], are broadcast to\n # operator.batch_shape = [2, 3].\n y = tf.random.normal(shape=[2, 1, 4, 2])\n x = operator.solve(y)\n ==> operator.matmul(x) = y\n ```\n\n #### Shape compatibility\n\n This operator acts on [batch] matrix with compatible shape.\n `x` is a batch matrix with compatible shape for `matmul` and `solve` if\n\n ```\n tensor_shape.TensorShape(operator.shape) = [B1,...,Bb] + [N, N], with b >= 0\n tensor_shape.TensorShape(x.shape) = [C1,...,Cc] + [N, R],\n and [C1,...,Cc] broadcasts with [B1,...,Bb] to [D1,...,Dd]\n ```\n\n #### Performance\n\n Suppose `operator` is a `LinearOperatorDiag` of shape `[N, N]`,\n and `tensor_shape.TensorShape(x.shape) = [N, R]`. Then\n\n * `operator.matmul(x)` involves `N * R` multiplications.\n * `operator.solve(x)` involves `N` divisions and `N * R` multiplications.\n * `operator.determinant()` involves a size `N` `reduce_prod`.\n\n If instead `operator` and `x` have shape `[B1,...,Bb, N, N]` and\n `[B1,...,Bb, N, R]`, every operation increases in complexity by `B1*...*Bb`.\n\n #### Matrix property hints\n\n This `LinearOperator` is initialized with boolean flags of the form `is_X`,\n for `X = non_singular, self_adjoint, positive_definite, square`.\n These have the following meaning:\n\n * If `is_X == True`, callers should expect the operator to have the\n property `X`. This is a promise that should be fulfilled, but is *not* a\n runtime assert. For example, finite floating point precision may result\n in these promises being violated.\n * If `is_X == False`, callers should expect the operator to not have `X`.\n * If `is_X == None` (the default), callers should have no expectation either\n way.\n \"\"\"\n\n def __init__(self,\n diag,\n is_non_singular=None,\n is_self_adjoint=None,\n is_positive_definite=None,\n is_square=None,\n name=\"LinearOperatorDiag\"):\n r\"\"\"Initialize a `LinearOperatorDiag`.\n\n Args:\n diag: Shape `[B1,...,Bb, N]` `Tensor` with `b >= 0` `N >= 0`.\n The diagonal of the operator. Allowed dtypes: `float16`, `float32`,\n `float64`, `complex64`, `complex128`.\n is_non_singular: Expect that this operator is non-singular.\n is_self_adjoint: Expect that this operator is equal to its hermitian\n transpose. If `diag.dtype` is real, this is auto-set to `True`.\n is_positive_definite: Expect that this operator is positive definite,\n meaning the quadratic form `x^H A x` has positive real part for all\n nonzero `x`. Note that we do not require the operator to be\n self-adjoint to be positive-definite. See:\n https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices\n is_square: Expect that this operator acts like square [batch] matrices.\n name: A name for this `LinearOperator`.\n\n Raises:\n TypeError: If `diag.dtype` is not an allowed type.\n ValueError: If `diag.dtype` is real, and `is_self_adjoint` is not `True`.\n \"\"\"\n\n with ops.name_scope(name, values=[diag]):\n self._diag = linear_operator_util.convert_nonref_to_tensor(\n diag, name=\"diag\")\n self._check_diag(self._diag)\n\n # Check and auto-set hints.\n if not np.issubdtype(self._diag.dtype, np.complexfloating):\n if is_self_adjoint is False:\n raise ValueError(\"A real diagonal operator is always self adjoint.\")\n else:\n is_self_adjoint = True\n\n if is_square is False:\n raise ValueError(\"Only square diagonal operators currently supported.\")\n is_square = True\n\n super(LinearOperatorDiag, self).__init__(\n dtype=self._diag.dtype,\n graph_parents=None,\n is_non_singular=is_non_singular,\n is_self_adjoint=is_self_adjoint,\n is_positive_definite=is_positive_definite,\n is_square=is_square,\n name=name)\n # TODO(b/143910018) Remove graph_parents in V3.\n self._set_graph_parents([self._diag])\n\n def _check_diag(self, diag):\n \"\"\"Static check of diag.\"\"\"\n if tensor_shape.TensorShape(diag.shape).ndims is not None and tensor_shape.TensorShape(diag.shape).ndims < 1:\n raise ValueError(\"Argument diag must have at least 1 dimension. \"\n \"Found: %s\" % diag)\n\n def _shape(self):\n # If d_shape = [5, 3], we return [5, 3, 3].\n d_shape = tensor_shape.TensorShape(self._diag.shape)\n return d_shape.concatenate(d_shape[-1:])\n\n def _shape_tensor(self):\n d_shape = array_ops.shape(self._diag)\n k = d_shape[-1]\n return array_ops.concat((d_shape, [k]), 0)\n\n @property\n def diag(self):\n return self._diag\n\n def _assert_non_singular(self):\n return linear_operator_util.assert_no_entries_with_modulus_zero(\n self._diag,\n message=\"Singular operator: Diagonal contained zero values.\")\n\n def _assert_positive_definite(self):\n if np.issubdtype(self.dtype, np.complexfloating):\n message = (\n \"Diagonal operator had diagonal entries with non-positive real part, \"\n \"thus was not positive definite.\")\n else:\n message = (\n \"Real diagonal operator had non-positive diagonal entries, \"\n \"thus was not positive definite.\")\n\n return check_ops.assert_positive(\n math_ops.real(self._diag),\n message=message)\n\n def _assert_self_adjoint(self):\n return linear_operator_util.assert_zero_imag_part(\n self._diag,\n message=(\n \"This diagonal operator contained non-zero imaginary values. \"\n \" Thus it was not self-adjoint.\"))\n\n def _matmul(self, x, adjoint=False, adjoint_arg=False):\n diag_term = math_ops.conj(self._diag) if adjoint else self._diag\n x = linalg.adjoint(x) if adjoint_arg else x\n diag_mat = array_ops.expand_dims(diag_term, -1)\n return diag_mat * x\n\n def _matvec(self, x, adjoint=False):\n diag_term = math_ops.conj(self._diag) if adjoint else self._diag\n return diag_term * x\n\n def _determinant(self):\n return math_ops.reduce_prod(self._diag, axis=[-1])\n\n def _log_abs_determinant(self):\n log_det = math_ops.reduce_sum(\n math_ops.log(math_ops.abs(self._diag)), axis=[-1])\n if np.issubdtype(self.dtype, np.complexfloating):\n log_det = _ops.cast(log_det, dtype=self.dtype)\n return log_det\n\n def _solve(self, rhs, adjoint=False, adjoint_arg=False):\n diag_term = math_ops.conj(self._diag) if adjoint else self._diag\n rhs = linalg.adjoint(rhs) if adjoint_arg else rhs\n inv_diag_mat = array_ops.expand_dims(1. / diag_term, -1)\n return rhs * inv_diag_mat\n\n def _to_dense(self):\n return _linalg.diag(self._diag)\n\n def _diag_part(self):\n return self.diag\n\n def _add_to_tensor(self, x):\n x_diag = _linalg.diag_part(x)\n new_diag = self._diag + x_diag\n return _linalg.set_diag(x, new_diag)\n\n def _eigvals(self):\n return ops.convert_to_tensor(self.diag)\n\n def _cond(self):\n abs_diag = math_ops.abs(self.diag)\n return (math_ops.reduce_max(abs_diag, axis=-1) /\n math_ops.reduce_min(abs_diag, axis=-1))\n\nimport numpy as np\nfrom tensorflow_probability.python.internal.backend.numpy import linalg_impl as _linalg\nfrom tensorflow_probability.python.internal.backend.numpy import ops as _ops\nfrom tensorflow_probability.python.internal.backend.numpy.gen import tensor_shape\n\nfrom tensorflow_probability.python.internal.backend.numpy import private\ndistribution_util = private.LazyLoader(\n \"distribution_util\", globals(),\n \"tensorflow_probability.python.internal._numpy.distribution_util\")\ntensorshape_util = private.LazyLoader(\n \"tensorshape_util\", globals(),\n \"tensorflow_probability.python.internal._numpy.tensorshape_util\")\n\n",
"# Copyright 2018 The TensorFlow Probability 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\"\"\"Trains a grammar variational auto-encoder on synthetic data.\n\nThe grammar variational auto-encoder (VAE) [1] posits a generative model over\nproductions from a context-free grammar, and it posits an amortized variational\napproximation for efficient posterior inference. We train the grammar VAE\non synthetic data using the grammar from [1] (Figure 1). Note for real data\nanalyses, one should implement a parser to convert examples into lists of\nproduction rules.\n\nThis example showcases eager execution in order to train a model where data\npoints have a variable number of time steps (that is, without padding). However,\nnote that handling a variable number of time steps requires a batch size of 1.\nIn this example, we assume data points arrive in a stream, one at a time. Such a\nsetting has an unbounded maximum length which prevents padding.\n\nSummaries are written under the flag `model_dir`. Point TensorBoard to that\ndirectory in order to monitor progress.\n\nExample output:\n\n```none\nRandom examples from synthetic data distribution:\n222N1N21c\n1c2N2C2C12C1N\nC11C12c\n2C\nNCC\n\nStep: 0 Loss: -13.724 (0.494 sec)\nStep: 500 Loss: -0.004 (145.741 sec)\nStep: 1000 Loss: -0.000 (292.205 sec)\nStep: 1500 Loss: -0.000 (438.819 sec)\n```\n\n#### References\n\n[1]: Matt J. Kusner, Brooks Paige, and Jose Miguel Hernandez-Lobato. Grammar\n Variational Autoencoder. In _International Conference on Machine Learning_,\n 2017. https://arxiv.org/abs/1703.01925\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport time\n\n# Dependency imports\nfrom absl import flags\nimport six\nimport tensorflow.compat.v1 as tf\nimport tensorflow_probability as tfp\n\nfrom tensorflow_probability import edward2 as ed\n\nflags.DEFINE_float(\"learning_rate\",\n default=1e-4,\n help=\"Initial learning rate.\")\nflags.DEFINE_integer(\"max_steps\",\n default=5000,\n help=\"Number of training steps to run.\")\nflags.DEFINE_integer(\"latent_size\",\n default=128,\n help=\"Number of dimensions in the latent code.\")\nflags.DEFINE_integer(\"num_units\",\n default=256,\n help=\"Number of units in the generative model's LSTM.\")\nflags.DEFINE_string(\"model_dir\",\n default=os.path.join(os.getenv(\"TEST_TMPDIR\", \"/tmp\"),\n \"grammar_vae/\"),\n help=\"Directory to put the model's fit.\")\n\nFLAGS = flags.FLAGS\n\n\nclass SmilesGrammar(object):\n \"\"\"Context-free grammar for SMILES strings.\n\n A context-free grammar is a 4-tuple consisting of the following elements:\n\n + `nonterminal_symbols`: finite set of strings.\n + `alphabet`: finite set of strings (terminal symbols). It is disjoint from\n `nonterminal_symbols`.\n + `production_rules`: list of 2-tuples. The first and second elements of\n each tuple respectively denote the left-hand-side and right-hand-side of a\n production rule. All right-hand-sides are written as lists, since the\n number of right-hand-side symbols may be greater than 1.\n + `start_symbol`: string, a distinct nonterminal symbol.\n \"\"\"\n\n @property\n def nonterminal_symbols(self):\n return {\"smiles\", \"chain\", \"branched atom\", \"atom\", \"ringbond\",\n \"aromatic organic\", \"aliphatic organic\", \"digit\"}\n\n @property\n def alphabet(self):\n return {\"c\", \"C\", \"N\", \"1\", \"2\"}\n\n @property\n def production_rules(self):\n return [\n (\"smiles\", [\"chain\"]),\n (\"chain\", [\"chain\", \"branched atom\"]),\n (\"chain\", [\"branched atom\"]),\n (\"branched atom\", [\"atom\", \"ringbond\"]),\n (\"branched atom\", [\"atom\"]),\n (\"atom\", [\"aromatic organic\"]),\n (\"atom\", [\"aliphatic organic\"]),\n (\"ringbond\", [\"digit\"]),\n (\"aromatic organic\", [\"c\"]),\n (\"aliphatic organic\", [\"C\"]),\n (\"aliphatic organic\", [\"N\"]),\n (\"digit\", [\"1\"]),\n (\"digit\", [\"2\"]),\n ]\n\n @property\n def start_symbol(self):\n return \"smiles\"\n\n def convert_to_string(self, productions):\n \"\"\"Converts a sequence of productions into a string of terminal symbols.\n\n Args:\n productions: Tensor of shape [1, num_productions, num_production_rules].\n Slices along the `num_productions` dimension represent one-hot vectors.\n\n Returns:\n str that concatenates all terminal symbols from `productions`.\n\n Raises:\n ValueError: If the first production rule does not begin with\n `self.start_symbol`.\n \"\"\"\n symbols = []\n for production in tf.unstack(productions, axis=1):\n lhs, rhs = self.production_rules[\n tf.argmax(input=tf.squeeze(production), axis=-1)]\n if not symbols: # first iteration\n if lhs != self.start_symbol:\n raise ValueError(\"`productions` must begin with `self.start_symbol`.\")\n symbols = rhs\n else:\n # Greedily unroll the nonterminal symbols based on the first occurrence\n # in a linear sequence.\n index = symbols.index(lhs)\n symbols = symbols[:index] + rhs + symbols[index + 1:]\n string = \"\".join(symbols)\n return string\n\n def mask(self, symbol, on_value, off_value):\n \"\"\"Produces a masking tensor for (in)valid production rules.\n\n Args:\n symbol: str, a symbol in the grammar.\n on_value: Value to use for a valid production rule.\n off_value: Value to use for an invalid production rule.\n\n Returns:\n Tensor of shape [1, num_production_rules]. An element is `on_value`\n if its corresponding production rule has `symbol` on its left-hand-side;\n the element is `off_value` otherwise.\n \"\"\"\n mask_values = [on_value if lhs == symbol else off_value\n for lhs, _ in self.production_rules]\n mask_values = tf.reshape(mask_values, [1, len(self.production_rules)])\n return mask_values\n\n\nclass ProbabilisticGrammar(tf.keras.Model):\n \"\"\"Deep generative model over productions that follow a grammar.\"\"\"\n\n def __init__(self, grammar, latent_size, num_units):\n \"\"\"Constructs a probabilistic grammar.\n\n Args:\n grammar: An object representing a grammar. It has members\n `nonterminal_symbols`, `alphabet`, `production_rules`, and\n `start_symbol`, and a method `mask` determining (in)valid\n production rules given a symbol.\n latent_size: Number of dimensions in the latent code.\n num_units: Number of units in the LSTM cell.\n \"\"\"\n super(ProbabilisticGrammar, self).__init__()\n self.grammar = grammar\n self.latent_size = latent_size\n self.lstm = tf.compat.v1.nn.rnn_cell.LSTMCell(num_units)\n self.output_layer = tf.keras.layers.Dense(len(grammar.production_rules))\n\n def __call__(self, *args, **kwargs):\n inputs = 0. # fixes a dummy variable so Model can be called without inputs\n return super(ProbabilisticGrammar, self).__call__(inputs, *args, **kwargs)\n\n def call(self, inputs):\n \"\"\"Runs the model forward to generate a sequence of productions.\n\n Args:\n inputs: Unused.\n\n Returns:\n productions: Tensor of shape [1, num_productions, num_production_rules].\n Slices along the `num_productions` dimension represent one-hot vectors.\n \"\"\"\n del inputs # unused\n latent_code = ed.MultivariateNormalDiag(loc=tf.zeros(self.latent_size),\n sample_shape=1,\n name=\"latent_code\")\n state = self.lstm.zero_state(1, dtype=tf.float32)\n t = 0\n productions = []\n stack = [self.grammar.start_symbol]\n while stack:\n symbol = stack.pop()\n net, state = self.lstm(latent_code, state)\n logits = (self.output_layer(net) +\n self.grammar.mask(symbol, on_value=0., off_value=-1e9))\n production = ed.OneHotCategorical(logits=logits,\n name=\"production_\" + str(t))\n _, rhs = self.grammar.production_rules[tf.argmax(\n input=tf.squeeze(production), axis=-1)]\n for symbol in rhs:\n if symbol in self.grammar.nonterminal_symbols:\n stack.append(symbol)\n productions.append(production)\n t += 1\n return tf.stack(productions, axis=1)\n\n\nclass ProbabilisticGrammarVariational(tf.keras.Model):\n \"\"\"Amortized variational posterior for a probabilistic grammar.\"\"\"\n\n def __init__(self, latent_size):\n \"\"\"Constructs a variational posterior for a probabilistic grammar.\n\n Args:\n latent_size: Number of dimensions in the latent code.\n \"\"\"\n super(ProbabilisticGrammarVariational, self).__init__()\n self.latent_size = latent_size\n self.encoder_net = tf.keras.Sequential([\n tf.keras.layers.Conv1D(64, 3, padding=\"SAME\"),\n tf.keras.layers.BatchNormalization(),\n tf.keras.layers.Activation(tf.nn.elu),\n tf.keras.layers.Conv1D(128, 3, padding=\"SAME\"),\n tf.keras.layers.BatchNormalization(),\n tf.keras.layers.Activation(tf.nn.elu),\n tf.keras.layers.Dropout(0.1),\n tf.keras.layers.GlobalAveragePooling1D(),\n tf.keras.layers.Dense(latent_size * 2, activation=None),\n ])\n\n def call(self, inputs):\n \"\"\"Runs the model forward to return a stochastic encoding.\n\n Args:\n inputs: Tensor of shape [1, num_productions, num_production_rules]. It is\n a sequence of productions of length `num_productions`. Each production\n is a one-hot vector of length `num_production_rules`: it determines\n which production rule the production corresponds to.\n\n Returns:\n latent_code_posterior: A random variable capturing a sample from the\n variational distribution, of shape [1, self.latent_size].\n \"\"\"\n net = self.encoder_net(tf.cast(inputs, tf.float32))\n return ed.MultivariateNormalDiag(\n loc=net[..., :self.latent_size],\n scale_diag=tf.nn.softplus(net[..., self.latent_size:]),\n name=\"latent_code_posterior\")\n\n\ndef main(argv):\n del argv # unused\n if tf.io.gfile.exists(FLAGS.model_dir):\n tf.compat.v1.logging.warning(\n \"Warning: deleting old log directory at {}\".format(FLAGS.model_dir))\n tf.io.gfile.rmtree(FLAGS.model_dir)\n tf.io.gfile.makedirs(FLAGS.model_dir)\n tf.compat.v1.enable_eager_execution()\n\n grammar = SmilesGrammar()\n synthetic_data_distribution = ProbabilisticGrammar(\n grammar=grammar, latent_size=FLAGS.latent_size, num_units=FLAGS.num_units)\n\n print(\"Random examples from synthetic data distribution:\")\n for _ in range(5):\n productions = synthetic_data_distribution()\n string = grammar.convert_to_string(productions)\n print(string)\n\n probabilistic_grammar = ProbabilisticGrammar(\n grammar=grammar, latent_size=FLAGS.latent_size, num_units=FLAGS.num_units)\n probabilistic_grammar_variational = ProbabilisticGrammarVariational(\n latent_size=FLAGS.latent_size)\n\n checkpoint = tf.train.Checkpoint(\n synthetic_data_distribution=synthetic_data_distribution,\n probabilistic_grammar=probabilistic_grammar,\n probabilistic_grammar_variational=probabilistic_grammar_variational)\n global_step = tf.compat.v1.train.get_or_create_global_step()\n optimizer = tf.compat.v1.train.AdamOptimizer(FLAGS.learning_rate)\n writer = tf.compat.v2.summary.create_file_writer(FLAGS.model_dir)\n writer.set_as_default()\n\n start_time = time.time()\n for step in range(FLAGS.max_steps):\n productions = synthetic_data_distribution()\n with tf.GradientTape() as tape:\n # Sample from amortized variational distribution and record its trace.\n with ed.tape() as variational_tape:\n _ = probabilistic_grammar_variational(productions)\n\n # Set model trace to take on the data's values and the sample from the\n # variational distribution.\n values = {\"latent_code\": variational_tape[\"latent_code_posterior\"]}\n values.update({\"production_\" + str(t): production for t, production\n in enumerate(tf.unstack(productions, axis=1))})\n with ed.tape() as model_tape:\n with ed.interception(ed.make_value_setter(**values)):\n _ = probabilistic_grammar()\n\n # Compute the ELBO given the variational sample, averaged over the batch\n # size and the number of time steps (number of productions). Although the\n # ELBO per data point sums over time steps, we average in order to have a\n # value that remains on the same scale across batches.\n log_likelihood = 0.\n for name, rv in six.iteritems(model_tape):\n if name.startswith(\"production\"):\n log_likelihood += rv.distribution.log_prob(rv.value)\n\n kl = tfp.distributions.kl_divergence(\n variational_tape[\"latent_code_posterior\"].distribution,\n model_tape[\"latent_code\"].distribution)\n\n timesteps = tf.cast(productions.shape[1], dtype=tf.float32)\n elbo = tf.reduce_mean(input_tensor=log_likelihood - kl) / timesteps\n loss = -elbo\n with tf.compat.v2.summary.record_if(\n lambda: tf.math.equal(0, global_step % 500)):\n tf.compat.v2.summary.scalar(\n \"log_likelihood\",\n tf.reduce_mean(input_tensor=log_likelihood) / timesteps,\n step=global_step)\n tf.compat.v2.summary.scalar(\n \"kl\", tf.reduce_mean(input_tensor=kl) / timesteps, step=global_step)\n tf.compat.v2.summary.scalar(\"elbo\", elbo, step=global_step)\n\n variables = (probabilistic_grammar.variables\n + probabilistic_grammar_variational.variables)\n grads = tape.gradient(loss, variables)\n grads_and_vars = list(zip(grads, variables))\n optimizer.apply_gradients(grads_and_vars, global_step)\n\n if step % 500 == 0:\n duration = time.time() - start_time\n print(\"Step: {:>3d} Loss: {:.3f} ({:.3f} sec)\".format(\n step, loss, duration))\n checkpoint.save(file_prefix=FLAGS.model_dir)\n\nif __name__ == \"__main__\":\n tf.compat.v1.app.run()\n",
"# Copyright 2018 The TensorFlow Probability 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\"\"\"Tests for the Sample distribution.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n# Dependency imports\n\nfrom absl.testing import parameterized\nimport numpy as np\nimport tensorflow.compat.v2 as tf\nfrom tensorflow_probability.python import bijectors as tfb\nfrom tensorflow_probability.python import distributions as tfd\nfrom tensorflow_probability.python.internal import test_util\n\n\n@test_util.test_all_tf_execution_regimes\nclass SampleDistributionTest(test_util.TestCase):\n\n def test_everything_scalar(self):\n s = tfd.Sample(tfd.Normal(loc=0, scale=1), 5, validate_args=True)\n x = s.sample(seed=test_util.test_seed())\n actual_lp = s.log_prob(x)\n # Sample.log_prob will reduce over event space, ie, dims [0, 2]\n # corresponding to sizes concat([[5], [2]]).\n expected_lp = tf.reduce_sum(s.distribution.log_prob(x), axis=0)\n x_, actual_lp_, expected_lp_ = self.evaluate([x, actual_lp, expected_lp])\n self.assertEqual((5,), x_.shape)\n self.assertEqual((), actual_lp_.shape)\n self.assertAllClose(expected_lp_, actual_lp_, atol=0, rtol=1e-3)\n\n def test_everything_nonscalar(self):\n s = tfd.Sample(\n tfd.Independent(tfd.Normal(loc=tf.zeros([3, 2]), scale=1), 1), [5, 4],\n validate_args=True)\n x = s.sample([6, 1], seed=test_util.test_seed())\n actual_lp = s.log_prob(x)\n # Sample.log_prob will reduce over event space, ie, dims [2, 3, 5]\n # corresponding to sizes concat([[5, 4], [2]]).\n expected_lp = tf.reduce_sum(\n s.distribution.log_prob(tf.transpose(a=x, perm=[0, 1, 3, 4, 2, 5])),\n axis=[2, 3])\n x_, actual_lp_, expected_lp_ = self.evaluate([x, actual_lp, expected_lp])\n self.assertEqual((6, 1, 3, 5, 4, 2), x_.shape)\n self.assertEqual((6, 1, 3), actual_lp_.shape)\n self.assertAllClose(expected_lp_, actual_lp_, atol=0, rtol=1e-3)\n\n def test_mixed_scalar(self):\n s = tfd.Sample(tfd.Independent(tfd.Normal(loc=[0., 0], scale=1), 1),\n 3, validate_args=False)\n x = s.sample(4, seed=test_util.test_seed())\n lp = s.log_prob(x)\n self.assertEqual((4, 3, 2), x.shape)\n self.assertEqual((4,), lp.shape)\n\n def test_kl_divergence(self):\n q_scale = 2.\n p = tfd.Sample(\n tfd.Independent(tfd.Normal(loc=tf.zeros([3, 2]), scale=1), 1), [5, 4],\n validate_args=True)\n q = tfd.Sample(\n tfd.Independent(tfd.Normal(loc=tf.zeros([3, 2]), scale=2.), 1), [5, 4],\n validate_args=True)\n actual_kl = tfd.kl_divergence(p, q)\n expected_kl = ((5 * 4) *\n (0.5 * q_scale**-2. - 0.5 + np.log(q_scale)) * # Actual KL.\n np.ones([3]) * 2) # Batch, events.\n self.assertAllClose(expected_kl, self.evaluate(actual_kl))\n\n def test_transformed_affine(self):\n sample_shape = 3\n mvn = tfd.Independent(tfd.Normal(loc=[0., 0], scale=1), 1)\n aff = tfb.Affine(scale_tril=[[0.75, 0.],\n [0.05, 0.5]])\n\n def expected_lp(y):\n x = aff.inverse(y) # Ie, tf.random.normal([4, 3, 2])\n fldj = aff.forward_log_det_jacobian(x, event_ndims=1)\n return tf.reduce_sum(mvn.log_prob(x) - fldj, axis=1)\n\n # Transform a Sample.\n d = tfd.TransformedDistribution(\n tfd.Sample(mvn, sample_shape, validate_args=True),\n bijector=aff)\n y = d.sample(4, seed=test_util.test_seed())\n actual_lp = d.log_prob(y)\n self.assertAllEqual((4,) + (sample_shape,) + (2,), y.shape)\n self.assertAllEqual((4,), actual_lp.shape)\n self.assertAllClose(\n *self.evaluate([expected_lp(y), actual_lp]),\n atol=0., rtol=1e-3)\n\n # Sample a Transform.\n d = tfd.Sample(\n tfd.TransformedDistribution(mvn, bijector=aff),\n sample_shape,\n validate_args=True)\n y = d.sample(4, seed=test_util.test_seed())\n actual_lp = d.log_prob(y)\n self.assertAllEqual((4,) + (sample_shape,) + (2,), y.shape)\n self.assertAllEqual((4,), actual_lp.shape)\n self.assertAllClose(\n *self.evaluate([expected_lp(y), actual_lp]),\n atol=0., rtol=1e-3)\n\n def test_transformed_exp(self):\n sample_shape = 3\n mvn = tfd.Independent(tfd.Normal(loc=[0., 0], scale=1), 1)\n exp = tfb.Exp()\n\n def expected_lp(y):\n x = exp.inverse(y) # Ie, tf.random.normal([4, 3, 2])\n fldj = exp.forward_log_det_jacobian(x, event_ndims=1)\n return tf.reduce_sum(mvn.log_prob(x) - fldj, axis=1)\n\n # Transform a Sample.\n d = tfd.TransformedDistribution(\n tfd.Sample(mvn, sample_shape, validate_args=True),\n bijector=exp)\n y = d.sample(4, seed=test_util.test_seed())\n actual_lp = d.log_prob(y)\n self.assertAllEqual((4,) + (sample_shape,) + (2,), y.shape)\n self.assertAllEqual((4,), actual_lp.shape)\n # If `TransformedDistribution` didn't scale the jacobian by\n # `_sample_distribution_size`, then `scale_fldj` would need to be `False`.\n self.assertAllClose(\n *self.evaluate([expected_lp(y), actual_lp]),\n atol=0., rtol=1e-3)\n\n # Sample a Transform.\n d = tfd.Sample(\n tfd.TransformedDistribution(mvn, bijector=exp),\n sample_shape,\n validate_args=True)\n y = d.sample(4, seed=test_util.test_seed())\n actual_lp = d.log_prob(y)\n self.assertAllEqual((4,) + (sample_shape,) + (2,), y.shape)\n self.assertAllEqual((4,), actual_lp.shape)\n # Regardless of whether `TransformedDistribution` scales the jacobian by\n # `_sample_distribution_size`, `scale_fldj` is `True`.\n self.assertAllClose(\n *self.evaluate([expected_lp(y), actual_lp]),\n atol=0., rtol=1e-3)\n\n @parameterized.parameters(\n 'mean',\n 'stddev',\n 'variance',\n 'mode',\n )\n def test_summary_statistic(self, attr):\n sample_shape = [5, 4]\n mvn = tfd.Independent(tfd.Normal(loc=tf.zeros([3, 2]), scale=1), 1)\n d = tfd.Sample(mvn, sample_shape, validate_args=True)\n self.assertEqual((3,), d.batch_shape)\n expected_stat = (\n getattr(mvn, attr)()[:, tf.newaxis, tf.newaxis, :] *\n tf.ones([3, 5, 4, 2]))\n actual_stat = getattr(d, attr)()\n self.assertAllEqual(*self.evaluate([expected_stat, actual_stat]))\n\n def test_entropy(self):\n sample_shape = [3, 4]\n mvn = tfd.Independent(tfd.Normal(loc=0, scale=[[0.25, 0.5]]), 1)\n d = tfd.Sample(mvn, sample_shape, validate_args=True)\n expected_entropy = 12 * tf.reduce_sum(mvn.distribution.entropy(), axis=-1)\n actual_entropy = d.entropy()\n self.assertAllEqual(*self.evaluate([expected_entropy, actual_entropy]))\n\n @test_util.tf_tape_safety_test\n def test_gradients_through_params(self):\n loc = tf.Variable(tf.zeros([4, 5, 3]), shape=tf.TensorShape(None))\n scale = tf.Variable(tf.ones([]), shape=tf.TensorShape(None))\n # In real life, you'd really always want `sample_shape` to be\n # `trainable=False`.\n sample_shape = tf.Variable([1, 2], shape=tf.TensorShape(None))\n dist = tfd.Sample(\n tfd.Independent(tfd.Logistic(loc=loc, scale=scale),\n reinterpreted_batch_ndims=1),\n sample_shape=sample_shape,\n validate_args=True)\n with tf.GradientTape() as tape:\n loss = -dist.log_prob(0.)\n self.assertLen(dist.trainable_variables, 3)\n grad = tape.gradient(loss, [loc, scale, sample_shape])\n self.assertAllNotNone(grad[:-1])\n self.assertIs(grad[-1], None)\n\n @test_util.tf_tape_safety_test\n def test_variable_shape_change(self):\n loc = tf.Variable(tf.zeros([4, 5, 3]), shape=tf.TensorShape(None))\n scale = tf.Variable(tf.ones([]), shape=tf.TensorShape(None))\n # In real life, you'd really always want `sample_shape` to be\n # `trainable=False`.\n sample_shape = tf.Variable([1, 2], shape=tf.TensorShape(None))\n dist = tfd.Sample(\n tfd.Independent(tfd.Logistic(loc=loc, scale=scale),\n reinterpreted_batch_ndims=1),\n sample_shape=sample_shape,\n validate_args=True)\n self.evaluate([v.initializer for v in dist.trainable_variables])\n\n x = dist.mean()\n y = dist.sample([7, 2], seed=test_util.test_seed())\n loss_x = -dist.log_prob(x)\n loss_0 = -dist.log_prob(0.)\n batch_shape = dist.batch_shape_tensor()\n event_shape = dist.event_shape_tensor()\n [x_, y_, loss_x_, loss_0_, batch_shape_, event_shape_] = self.evaluate([\n x, y, loss_x, loss_0, batch_shape, event_shape])\n self.assertAllEqual([4, 5, 1, 2, 3], x_.shape)\n self.assertAllEqual([7, 2, 4, 5, 1, 2, 3], y_.shape)\n self.assertAllEqual([4, 5], loss_x_.shape)\n self.assertAllEqual([4, 5], loss_0_.shape)\n self.assertAllEqual([4, 5], batch_shape_)\n self.assertAllEqual([1, 2, 3], event_shape_)\n self.assertLen(dist.trainable_variables, 3)\n\n with tf.control_dependencies([\n loc.assign(tf.zeros([])),\n scale.assign(tf.ones([3, 1, 2])),\n sample_shape.assign(6),\n ]):\n x = dist.mean()\n y = dist.sample([7, 2], seed=test_util.test_seed())\n loss_x = -dist.log_prob(x)\n loss_0 = -dist.log_prob(0.)\n batch_shape = dist.batch_shape_tensor()\n event_shape = dist.event_shape_tensor()\n [x_, y_, loss_x_, loss_0_, batch_shape_, event_shape_] = self.evaluate([\n x, y, loss_x, loss_0, batch_shape, event_shape])\n self.assertAllEqual([3, 1, 6, 2], x_.shape)\n self.assertAllEqual([7, 2, 3, 1, 6, 2], y_.shape)\n self.assertAllEqual([3, 1], loss_x_.shape)\n self.assertAllEqual([3, 1], loss_0_.shape)\n self.assertAllEqual([3, 1], batch_shape_)\n self.assertAllEqual([6, 2], event_shape_)\n self.assertLen(dist.trainable_variables, 3)\n\n def test_variable_sample_shape_exception(self):\n loc = tf.Variable(tf.zeros([4, 5, 3]), shape=tf.TensorShape(None))\n scale = tf.Variable(tf.ones([]), shape=tf.TensorShape(None))\n sample_shape = tf.Variable([[1, 2]], shape=tf.TensorShape(None))\n with self.assertRaisesWithPredicateMatch(\n Exception,\n 'Argument `sample_shape` must be either a scalar or a vector.'):\n dist = tfd.Sample(\n tfd.Independent(tfd.Logistic(loc=loc, scale=scale),\n reinterpreted_batch_ndims=1),\n sample_shape=sample_shape,\n validate_args=True)\n self.evaluate([v.initializer for v in dist.trainable_variables])\n self.evaluate(dist.mean())\n\n\nif __name__ == '__main__':\n tf.test.main()\n",
"# Copyright 2019 The TensorFlow Probability 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\"\"\"Base class for variational layers for building neural networks.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport collections\n\nimport tensorflow.compat.v2 as tf\n\nfrom tensorflow_probability.python import random as tfp_random\nfrom tensorflow_probability.python.distributions import distribution as distribution_lib\nfrom tensorflow_probability.python.distributions import independent as independent_lib\nfrom tensorflow_probability.python.distributions import kullback_leibler as kl_lib\nfrom tensorflow_probability.python.distributions import mvn_diag as mvn_diag_lib\nfrom tensorflow_probability.python.distributions import normal as normal_lib\nfrom tensorflow_probability.python.experimental.nn import layers as layers_lib\nfrom tensorflow_probability.python.internal import prefer_static\nfrom tensorflow_probability.python.internal.reparameterization import FULLY_REPARAMETERIZED\nfrom tensorflow_probability.python.monte_carlo import expectation\nfrom tensorflow_probability.python.util.seed_stream import SeedStream\n\n\n__all__ = [\n 'VariationalLayer',\n]\n\n\n# The following aliases ensure docstrings read more succinctly.\ntfd = distribution_lib\n\n\ndef kl_divergence_monte_carlo(q, r, w):\n \"\"\"Monte Carlo KL Divergence.\"\"\"\n return expectation(\n lambda w: q.log_prob(w) - r.log_prob(w),\n samples=w,\n log_prob=q.log_prob,\n use_reparameterization=all(\n rt == FULLY_REPARAMETERIZED\n for rt in tf.nest.flatten(q.reparameterization_type)),\n axis=())\n\n\ndef kl_divergence_exact(q, r, w): # pylint: disable=unused-argument\n \"\"\"Exact KL Divergence.\"\"\"\n return kl_lib.kl_divergence(q, r)\n\n\ndef unpack_kernel_and_bias(weights):\n \"\"\"Returns `kernel`, `bias` tuple.\"\"\"\n if isinstance(weights, collections.Mapping):\n kernel = weights.get('kernel', None)\n bias = weights.get('bias', None)\n elif len(weights) == 1:\n kernel, bias = weights, None\n elif len(weights) == 2:\n kernel, bias = weights\n else:\n raise ValueError('Unable to unpack weights: {}.'.format(weights))\n return kernel, bias\n\n\nclass VariationalLayer(layers_lib.Layer):\n \"\"\"Base class for all variational layers.\"\"\"\n\n def __init__(\n self,\n posterior,\n prior,\n activation_fn=None,\n penalty_weight=None,\n posterior_penalty_fn=kl_divergence_monte_carlo,\n posterior_value_fn=tfd.Distribution.sample,\n seed=None,\n dtype=tf.float32,\n name=None):\n \"\"\"Base class for variational layers.\n\n # mean ==> penalty_weight = 1 / train_size\n # sum ==> penalty_weight = batch_size / train_size\n\n Args:\n posterior: ...\n prior: ...\n activation_fn: ...\n penalty_weight: ...\n posterior_penalty_fn: ...\n posterior_value_fn: ...\n seed: ...\n dtype: ...\n name: Python `str` prepeneded to ops created by this object.\n Default value: `None` (i.e., `type(self).__name__`).\n \"\"\"\n super(VariationalLayer, self).__init__(name=name)\n self._posterior = posterior\n self._prior = prior\n self._activation_fn = activation_fn\n self._penalty_weight = penalty_weight\n self._posterior_penalty_fn = posterior_penalty_fn\n self._posterior_value_fn = posterior_value_fn\n self._seed = SeedStream(seed, salt=self.name)\n self._dtype = dtype\n tf.nest.assert_same_structure(prior.dtype, posterior.dtype,\n check_types=False)\n\n @property\n def dtype(self):\n return self._dtype\n\n @property\n def posterior(self):\n return self._posterior\n\n @property\n def prior(self):\n return self._prior\n\n @property\n def activation_fn(self):\n return self._activation_fn\n\n @property\n def penalty_weight(self):\n return self._penalty_weight\n\n @property\n def posterior_penalty_fn(self):\n return self._posterior_penalty_fn\n\n @property\n def posterior_value_fn(self):\n return self._posterior_value_fn\n\n def eval(self, inputs, is_training=True, **kwargs):\n inputs = tf.convert_to_tensor(inputs, dtype=self.dtype, name='inputs')\n w = self.posterior_value_fn(self.posterior, seed=self._seed()) # pylint: disable=not-callable\n if is_training:\n penalty = self.posterior_penalty_fn(self.posterior, self.prior, w) # pylint: disable=not-callable\n if penalty is not None and self.penalty_weight is not None:\n penalty *= tf.cast(self.penalty_weight, dtype=penalty.dtype)\n else:\n penalty = None\n outputs = self._eval(inputs, w, **kwargs)\n self._set_extra_loss(penalty)\n self._set_extra_result(w)\n return outputs\n\n def _eval(self, inputs, weights):\n raise NotImplementedError('Subclass failed to implement `_eval`.')\n\n\nclass VariationalReparameterizationKernelBiasLayer(VariationalLayer):\n \"\"\"Variational reparameterization linear layer.\"\"\"\n\n def __init__(\n self,\n posterior,\n prior,\n apply_kernel_fn,\n activation_fn=None,\n penalty_weight=None,\n posterior_penalty_fn=kl_divergence_monte_carlo,\n posterior_value_fn=tfd.Distribution.sample,\n unpack_weights_fn=unpack_kernel_and_bias,\n seed=None,\n dtype=tf.float32,\n name=None):\n super(VariationalReparameterizationKernelBiasLayer, self).__init__(\n posterior,\n prior,\n activation_fn=activation_fn,\n penalty_weight=penalty_weight,\n posterior_penalty_fn=posterior_penalty_fn,\n posterior_value_fn=posterior_value_fn,\n seed=seed,\n dtype=dtype,\n name=name)\n self._apply_kernel_fn = apply_kernel_fn\n self._unpack_weights_fn = unpack_weights_fn\n\n @property\n def unpack_weights_fn(self):\n return self._unpack_weights_fn\n\n def _eval(self, x, weights):\n kernel, bias = self.unpack_weights_fn(weights) # pylint: disable=not-callable\n y = x\n if kernel is not None:\n y = self._apply_kernel_fn(y, kernel)\n if bias is not None:\n y = y + bias\n if self.activation_fn is not None:\n y = self.activation_fn(y) # pylint: disable=not-callable\n return y\n\n\nclass VariationalFlipoutKernelBiasLayer(VariationalLayer):\n \"\"\"Variational flipout linear layer.\"\"\"\n\n def __init__(\n self,\n posterior,\n prior,\n apply_kernel_fn,\n activation_fn=None,\n penalty_weight=None,\n posterior_penalty_fn=kl_divergence_monte_carlo,\n posterior_value_fn=tfd.Distribution.sample,\n unpack_weights_fn=unpack_kernel_and_bias,\n seed=None,\n dtype=tf.float32,\n name=None):\n super(VariationalFlipoutKernelBiasLayer, self).__init__(\n posterior,\n prior,\n activation_fn=activation_fn,\n penalty_weight=penalty_weight,\n posterior_penalty_fn=posterior_penalty_fn,\n posterior_value_fn=posterior_value_fn,\n seed=seed,\n dtype=dtype,\n name=name)\n self._apply_kernel_fn = apply_kernel_fn\n self._unpack_weights_fn = unpack_weights_fn\n\n @property\n def unpack_weights_fn(self):\n return self._unpack_weights_fn\n\n def _eval(self, x, weights):\n kernel, bias = self.unpack_weights_fn(weights) # pylint: disable=not-callable\n y = x\n\n if kernel is not None:\n kernel_dist, _ = self.unpack_weights_fn( # pylint: disable=not-callable\n self.posterior.sample_distributions(value=weights)[0])\n kernel_loc, kernel_scale = get_spherical_normal_loc_scale(kernel_dist)\n\n # batch_size = tf.shape(x)[0]\n # sign_input_shape = ([batch_size] +\n # [1] * self._rank +\n # [self._input_channels])\n y *= tfp_random.rademacher(prefer_static.shape(y),\n dtype=y.dtype,\n seed=self._seed())\n kernel_perturb = normal_lib.Normal(loc=0., scale=kernel_scale)\n y = self._apply_kernel_fn( # E.g., tf.matmul.\n y,\n kernel_perturb.sample(seed=self._seed()))\n y *= tfp_random.rademacher(prefer_static.shape(y),\n dtype=y.dtype,\n seed=self._seed())\n y += self._apply_kernel_fn(x, kernel_loc)\n\n if bias is not None:\n y = y + bias\n\n if self.activation_fn is not None:\n y = self.activation_fn(y) # pylint: disable=not-callable\n\n return y\n\n\ndef get_spherical_normal_loc_scale(d):\n if isinstance(d, independent_lib.Independent):\n return get_spherical_normal_loc_scale(d.distribution)\n if isinstance(d, (normal_lib.Normal, mvn_diag_lib.MultivariateNormalDiag)):\n return d.loc, d.scale\n raise TypeError('Expected kernel `posterior` to be spherical Normal; '\n 'saw: \"{}\".'.format(type(d).__name__))\n",
"# Copyright 2018 The TensorFlow Probability 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\"\"\"Tests for ReplicaExchangeMC.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom absl import logging\nfrom absl.testing import parameterized\n\nimport numpy as np\nimport tensorflow.compat.v2 as tf\nimport tensorflow_probability as tfp\n\nfrom tensorflow_probability.python.internal import prefer_static\nfrom tensorflow_probability.python.internal import samplers\nfrom tensorflow_probability.python.internal import test_util\n\n\ntfd = tfp.distributions\n\nJAX_MODE = False\n\n\ndef init_tfp_randomwalkmetropolis(\n target_log_prob_fn,\n step_size,\n seed=None, store_parameters_in_results=False, num_leapfrog_steps=None): # pylint: disable=unused-argument\n return tfp.mcmc.RandomWalkMetropolis(\n target_log_prob_fn,\n new_state_fn=tfp.mcmc.random_walk_normal_fn(scale=step_size),\n seed=seed)\n\n\ndef effective_sample_size(x, **kwargs):\n \"\"\"tfp.mcmc.effective_sample_size, with a maximum appropriate for HMC.\"\"\"\n # Since ESS is an estimate, it can go wrong... E.g. we can have negatively\n # correlated samples, which *do* have ESS > N, but this ESS is only applicable\n # for variance reduction power for estimation of the mean. We want to\n # (blindly) use ESS everywhere (e.g. variance estimates)....and so...\n ess = tfp.mcmc.effective_sample_size(x, **kwargs)\n n = tf.cast(prefer_static.size0(x), x.dtype)\n return tf.minimum(ess, n)\n\n\ndef _set_seed():\n \"\"\"Helper which uses graph seed if using TFE.\"\"\"\n # TODO(b/68017812): Deprecate once TFE supports seed.\n seed = test_util.test_seed()\n if tf.executing_eagerly() and not JAX_MODE:\n tf.random.set_seed(seed)\n return None\n return seed\n\n\n@test_util.test_graph_and_eager_modes\nclass DefaultSwapProposedFnTest(test_util.TestCase):\n\n @parameterized.named_parameters(\n ('prob1p0_n1', 1.0, 1),\n ('prob1p0_n2', 1.0, 2),\n ('prob1p0_n4', 1.0, 4),\n ('prob1p0_n5', 1.0, 5),\n ('prob0p5_n1', 0.5, 1),\n ('prob0p5_n4', 0.5, 4),\n ('prob0p5_n7', 0.5, 7),\n ('prob0p0_n1', 0.0, 1),\n ('prob0p0_n2', 0.0, 2),\n ('prob0p0_n5', 0.0, 5),\n )\n def testProbSwapNumReplicaNoBatch(self, prob_swap, num_replica):\n fn = tfp.mcmc.default_swap_proposal_fn(prob_swap)\n num_results = 100\n seeds = samplers.split_seed(test_util.test_seed(), n=num_results)\n swaps = tf.stack(\n [fn(num_replica, seed=seeds[i]) for i in range(num_results)],\n axis=0)\n\n self.assertAllEqual((num_results, num_replica), swaps.shape)\n self.check_swaps_with_no_batch_shape(self.evaluate(swaps), prob_swap)\n\n @parameterized.named_parameters(\n ('prob1p0_n1', 1.0, 1),\n ('prob1p0_n2', 1.0, 2),\n ('prob1p0_n5', 1.0, 5),\n ('prob0p5_n1', 0.5, 1),\n ('prob0p5_n2', 0.5, 2),\n ('prob0p5_n3', 0.5, 3),\n ('prob0p0_n1', 0.0, 1),\n ('prob0p0_n2', 0.0, 2),\n ('prob0p0_n5', 0.0, 5),\n )\n def testProbSwapNumReplicaWithBatch(self, prob_swap, num_replica):\n fn = tfp.mcmc.default_swap_proposal_fn(prob_swap)\n num_results = 100\n seeds = samplers.split_seed(test_util.test_seed(), n=num_results)\n swaps = tf.stack(\n [fn(num_replica, batch_shape=[2], seed=seeds[i])\n for i in range(num_results)],\n axis=0)\n\n self.assertAllEqual((num_results, num_replica, 2), swaps.shape)\n swaps_ = self.evaluate(swaps)\n\n # Batch members should have distinct swaps in most cases.\n frac_same = np.mean(swaps_[..., 0] == swaps_[..., 1])\n\n # If prob_swap == 0, swap is the null_swap always.\n if (prob_swap == 0 or\n # If num_replica == 1, swap = [0] always.\n num_replica == 1 or\n # In this case, we always swap and it's always [1, 0].\n (num_replica == 2 and prob_swap == 1)):\n self.assertEqual(1.0, frac_same)\n else:\n self.assertLess(frac_same, 0.9)\n\n # Check that each batch member has proper statistics.\n for i in range(swaps_.shape[-1]):\n self.check_swaps_with_no_batch_shape(swaps_[..., i], prob_swap)\n\n def check_swaps_with_no_batch_shape(self, swaps_, prob_swap):\n assert swaps_.ndim == 2, 'Expected shape [num_results, num_replica]'\n num_results, num_replica = swaps_.shape\n\n null_swaps = np.arange(num_replica)\n\n # Check that we propose at least one swap, prob_swap fraction of the\n # time.\n # An exception is made for when num_replica == 1, since in this case the\n # only swap is the null swap.\n expected_prob_swap = prob_swap * np.float32(num_replica > 1)\n observed_prob_swap = np.mean(np.any(swaps_ != null_swaps, axis=1))\n self.assertAllClose(\n expected_prob_swap,\n observed_prob_swap,\n rtol=0,\n # Accurate to 4 standard errors.\n atol=4 * np.sqrt(prob_swap * (1 - prob_swap) / num_results))\n\n # Verify the swap is \"once only.\"\n for n in range(20):\n self.assertAllEqual(null_swaps, np.take(swaps_[n], swaps_[n]))\n\n\n@test_util.test_graph_and_eager_modes\nclass REMCTest(test_util.TestCase):\n\n def setUp(self):\n tf.random.set_seed(123)\n super(REMCTest, self).setUp()\n\n @parameterized.named_parameters([\n dict( # pylint: disable=g-complex-comprehension\n testcase_name=(testcase_name + kernel_name +\n ['_fast_execute_only', '_slow_asserts'][asserts]),\n tfp_transition_kernel=tfp_transition_kernel,\n inverse_temperatures=inverse_temperatures,\n store_parameters_in_results=store_param,\n asserts=asserts)\n for asserts in [True, False]\n for kernel_name, tfp_transition_kernel, store_param in [\n ('HMC', tfp.mcmc.HamiltonianMonteCarlo, True), # NUMPY_DISABLE\n ('RWMH', init_tfp_randomwalkmetropolis, False),\n ]\n for testcase_name, inverse_temperatures in [\n ('OddNumReplicas', [1.0, 0.8, 0.6]),\n ('EvenNumReplicas', [1.0, 0.8, 0.7, 0.6]),\n ('HighTemperatureOnly', [0.5]),\n ('LowTemperatureOnly', [2.0]),\n ]\n ])\n def testNormal(self,\n tfp_transition_kernel,\n inverse_temperatures,\n store_parameters_in_results,\n asserts,\n prob_swap=1.0,\n dtype=np.float32):\n \"\"\"Sampling from standard normal with REMC.\"\"\"\n\n target = tfd.Normal(dtype(0.), dtype(1.))\n inverse_temperatures = dtype(inverse_temperatures)\n num_replica = len(inverse_temperatures)\n\n step_size = 0.51234 / np.sqrt(inverse_temperatures)\n num_leapfrog_steps = 3\n\n def make_kernel_fn(target_log_prob_fn):\n return tfp_transition_kernel(\n target_log_prob_fn=target_log_prob_fn,\n step_size=step_size,\n store_parameters_in_results=store_parameters_in_results,\n num_leapfrog_steps=num_leapfrog_steps)\n\n remc = tfp.mcmc.ReplicaExchangeMC(\n target_log_prob_fn=target.log_prob,\n inverse_temperatures=inverse_temperatures,\n make_kernel_fn=make_kernel_fn,\n swap_proposal_fn=tfp.mcmc.default_swap_proposal_fn(prob_swap))\n\n num_results = 17\n if asserts:\n num_results = 2000\n remc.one_step = tf.function(remc.one_step, autograph=False)\n\n states, kernel_results = tfp.mcmc.sample_chain(\n num_results=num_results,\n current_state=target.sample(seed=_set_seed()),\n kernel=remc,\n num_burnin_steps=50,\n trace_fn=lambda _, results: results,\n seed=_set_seed())\n\n self.assertAllEqual((num_results,), states.shape)\n\n states_, kr_, replica_ess_ = self.evaluate([\n states,\n kernel_results,\n # Get the first (and only) state part for all replicas.\n effective_sample_size(kernel_results.post_swap_replica_states[0]),\n ])\n\n logging.vlog(\n 2, '---- execution:{} mean:{} stddev:{}'.format(\n 'eager' if tf.executing_eagerly() else 'graph',\n states_.mean(), states_.std()))\n\n # Some shortened names.\n replica_log_accept_ratio = (\n kr_.post_swap_replica_results.log_accept_ratio)\n replica_states_ = kr_.post_swap_replica_states[0] # Get rid of \"parts\"\n\n # Target state is at index 0.\n self.assertAllClose(states_, replica_states_[:, 0])\n\n # Check that *each* replica has correct marginal.\n def _check_sample_stats(replica_idx):\n x = replica_states_[:, replica_idx]\n ess = replica_ess_[replica_idx]\n\n err_msg = 'replica_idx={}'.format(replica_idx)\n\n mean_atol = 6 * 1.0 / np.sqrt(ess)\n self.assertAllClose(x.mean(), 0.0, atol=mean_atol, msg=err_msg)\n\n # For a tempered Normal, Variance = T.\n expected_var = 1 / inverse_temperatures[replica_idx]\n var_atol = 6 * expected_var * np.sqrt(2) / np.sqrt(ess)\n self.assertAllClose(np.var(x), expected_var, atol=var_atol, msg=err_msg)\n\n if not asserts:\n return\n\n for replica_idx in range(num_replica):\n _check_sample_stats(replica_idx)\n\n # Test log_accept_ratio and replica_log_accept_ratio.\n self.assertAllEqual((num_results, num_replica),\n replica_log_accept_ratio.shape)\n replica_mean_accept_ratio = np.mean(\n np.exp(np.minimum(0, replica_log_accept_ratio)), axis=0)\n for accept_ratio in replica_mean_accept_ratio:\n # Every single replica should have a decent P[Accept]\n self.assertBetween(accept_ratio, 0.2, 0.99)\n\n # Check swap probabilities for adjacent swaps.\n self.assertAllEqual((num_results, num_replica - 1),\n kr_.is_swap_accepted_adjacent.shape)\n conditional_swap_prob = (\n np.sum(kr_.is_swap_accepted_adjacent, axis=0) /\n np.sum(kr_.is_swap_proposed_adjacent, axis=0)\n )\n if num_replica > 1 and prob_swap > 0:\n # If temperatures are reasonable, this should be the case.\n # Ideally conditional_swap_prob is near 30%, but we're not tuning here\n self.assertGreater(np.min(conditional_swap_prob), 0.01)\n self.assertLess(np.max(conditional_swap_prob), 0.99)\n\n # Check swap probabilities for all swaps.\n def _check_swap_matrix(matrix):\n self.assertAllEqual((num_results, num_replica, num_replica),\n matrix.shape)\n # Matrix is stochastic (since you either get swapped with another\n # replica, or yourself), and symmetric, since we do once-only swaps.\n self.assertAllEqual(np.ones((num_results, num_replica)),\n matrix.sum(axis=-1))\n self.assertAllEqual(matrix, np.transpose(matrix, (0, 2, 1)))\n # By default, all swaps are between adjacent replicas.\n for i in range(num_replica):\n for j in range(i + 2, num_replica):\n self.assertEqual(0.0, np.max(np.abs(matrix[..., i, j])))\n _check_swap_matrix(kr_.is_swap_proposed)\n _check_swap_matrix(kr_.is_swap_accepted)\n\n # Check inverse_temperatures never change.\n self.assertAllEqual(\n np.repeat([inverse_temperatures], axis=0, repeats=num_results),\n kr_.inverse_temperatures)\n\n if store_parameters_in_results:\n # Check that store_parameters_in_results=True worked for HMC.\n self.assertAllEqual(\n np.repeat([step_size], axis=0, repeats=num_results),\n kr_.post_swap_replica_results.accepted_results.step_size)\n\n self.assertAllEqual(\n np.repeat([num_leapfrog_steps], axis=0, repeats=num_results),\n kr_.post_swap_replica_results.accepted_results.num_leapfrog_steps)\n\n @parameterized.named_parameters([\n ('HMC', tfp.mcmc.HamiltonianMonteCarlo), # NUMPY_DISABLE\n ('RWMH', init_tfp_randomwalkmetropolis),\n ])\n def test2DMixNormal(self, tfp_transition_kernel):\n \"\"\"Sampling from a 2-D Mixture Normal Distribution.\"\"\"\n dtype = np.float32\n\n # By symmetry, target has mean [0, 0]\n # Therefore, Var = E[X^2] = E[E[X^2 | c]], where c is the component.\n # Now..., for the first component,\n # E[X1^2] = Var[X1] + Mean[X1]^2\n # = 0.3^2 + 1^2,\n # and similarly for the second. As a result, Var[mixture] = 1.09.\n target = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(probs=[0.5, 0.5]),\n components_distribution=tfd.MultivariateNormalDiag(\n loc=[[-1., -1], [1., 1.]],\n scale_identity_multiplier=0.3))\n\n inverse_temperatures = 10.**tf.linspace(start=0., stop=-1., num=4)\n # We need to pad the step_size so it broadcasts against MCMC samples. In\n # this case we have 1 replica dim, 0 batch dims, and 1 event dim hence need\n # to right pad the step_size by one dim (for the event).\n step_size = 0.2 / tf.math.sqrt(inverse_temperatures[:, tf.newaxis])\n def make_kernel_fn(target_log_prob_fn):\n return tfp_transition_kernel(\n target_log_prob_fn=target_log_prob_fn,\n step_size=step_size,\n num_leapfrog_steps=5)\n\n remc = tfp.mcmc.ReplicaExchangeMC(\n target_log_prob_fn=target.log_prob,\n # Verified that test fails if inverse_temperatures = [1.]\n inverse_temperatures=inverse_temperatures,\n make_kernel_fn=make_kernel_fn)\n remc.one_step = tf.function(remc.one_step, autograph=False)\n\n def trace_fn(state, results): # pylint: disable=unused-argument\n return results.post_swap_replica_results.log_accept_ratio\n\n num_results = 2000\n states, replica_log_accept_ratio = tfp.mcmc.sample_chain(\n num_results=num_results,\n # Start at one of the modes, in order to make mode jumping necessary\n # if we want to pass test.\n current_state=tf.ones(2, dtype=dtype),\n kernel=remc,\n num_burnin_steps=50,\n trace_fn=trace_fn,\n seed=test_util.test_seed())\n self.assertAllEqual((num_results, 2), states.shape)\n replica_accept_ratio = tf.reduce_mean(\n tf.math.exp(tf.minimum(0., replica_log_accept_ratio)),\n axis=0)\n\n [\n sample_mean_,\n sample_variance_,\n replica_accept_ratio_,\n expected_mean_,\n expected_stddev_,\n expected_variance_,\n ess_,\n ] = self.evaluate([\n tf.reduce_mean(states, axis=0),\n tfp.stats.variance(states),\n replica_accept_ratio,\n target.mean(),\n target.stddev(),\n target.variance(),\n effective_sample_size(states),\n ])\n\n logging.vlog(\n 2, '---- execution:{} accept_ratio:{} mean:{}'.format(\n 'eager' if tf.executing_eagerly() else 'graph',\n replica_accept_ratio_, sample_mean_))\n\n mean_atol = 6 * expected_stddev_ / np.sqrt(np.min(ess_))\n var_atol = 6 * expected_variance_ / np.sqrt(np.min(ess_))\n for i in range(mean_atol.shape[0]):\n self.assertAllClose(\n expected_mean_[i],\n sample_mean_[i],\n atol=mean_atol[i],\n msg='position {}'.format(i))\n self.assertAllClose(\n expected_variance_[i],\n sample_variance_[i],\n atol=var_atol[i],\n msg=i)\n\n @test_util.numpy_disable_gradient_test('HMC')\n def testMultipleCorrelatedStatesWithNoBatchDims(self):\n dtype = np.float32\n num_results = 2000\n true_mean = dtype([0, 0])\n true_cov = dtype([[1, 0.5], [0.5, 1]])\n # Use LinearOperatorLowerTriangular to get broadcasting ability.\n linop = tf.linalg.LinearOperatorLowerTriangular(\n tf.linalg.cholesky(true_cov))\n\n # Its ok to decorate this since we only need to stress the TransitionKernel.\n def target_log_prob(x, y):\n # Corresponds to unnormalized MVN.\n # z = matmul(inv(chol(true_cov)), [x, y] - true_mean)\n xy = tf.stack([x, y], axis=-1) - true_mean\n z = linop.solvevec(xy)\n return -0.5 * tf.reduce_sum(z**2., axis=-1)\n\n inverse_temperatures = tf.constant([1., 0.75, 0.5])\n # We need to pad the step_size so it broadcasts against MCMC samples. In\n # this case we have 1 replica dim, 0 batch dims, and 0 event dims (per each\n # of 2 state parts) hence no padding is needed.\n # We do however supply a step size for each state part.\n step_sizes = [0.9 / tf.math.sqrt(inverse_temperatures)]*2\n\n def make_kernel_fn(target_log_prob_fn):\n return tfp.mcmc.HamiltonianMonteCarlo(\n target_log_prob_fn=target_log_prob_fn,\n step_size=step_sizes,\n num_leapfrog_steps=3)\n\n remc = tfp.mcmc.ReplicaExchangeMC(\n target_log_prob_fn=target_log_prob,\n inverse_temperatures=inverse_temperatures,\n make_kernel_fn=make_kernel_fn)\n remc.one_step = tf.function(remc.one_step, autograph=False)\n\n def trace_fn(state, results): # pylint: disable=unused-argument\n return results.post_swap_replica_results.log_accept_ratio\n\n [samples_x, samples_y], replica_log_accept_ratio = tfp.mcmc.sample_chain(\n num_results=num_results,\n num_burnin_steps=200,\n current_state=[1., 1.],\n kernel=remc,\n trace_fn=trace_fn,\n seed=test_util.test_seed())\n samples = tf.stack([samples_x, samples_y], axis=-1)\n sample_mean = tf.reduce_mean(samples, axis=0)\n sample_cov = tfp.stats.covariance(samples, sample_axis=0)\n\n replica_accept_ratio = tf.reduce_mean(\n tf.math.exp(tf.minimum(0., replica_log_accept_ratio)),\n axis=0)\n\n [\n sample_mean_,\n sample_cov_,\n replica_accept_ratio_,\n ess_,\n ] = self.evaluate([\n sample_mean,\n sample_cov,\n replica_accept_ratio,\n effective_sample_size(samples),\n ])\n logging.vlog(\n 2, '---- execution:{} accept_ratio:{} mean:{} cov:{}'.format(\n 'eager' if tf.executing_eagerly() else 'graph',\n replica_accept_ratio_, sample_mean_, sample_cov_))\n\n self.assertAllEqual([num_results], samples_x.shape)\n self.assertAllEqual([num_results], samples_y.shape)\n\n max_scale = np.sqrt(np.max(true_cov))\n\n self.assertAllClose(\n true_mean, sample_mean_, atol=6 * max_scale / np.sqrt(np.min(ess_)))\n self.assertAllClose(\n true_cov, sample_cov_, atol=6 * max_scale**2 / np.sqrt(np.min(ess_)))\n\n @parameterized.named_parameters([\n dict( # pylint: disable=g-complex-comprehension\n testcase_name=testcase_name + kernel_name,\n tfp_transition_kernel=tfp_transition_kernel,\n inverse_temperatures=inverse_temperatures,\n step_size_fn=step_size_fn,\n ess_scaling=ess_scaling)\n for kernel_name, tfp_transition_kernel, ess_scaling in [\n ('HMC', tfp.mcmc.HamiltonianMonteCarlo, .1), # NUMPY_DISABLE\n ('RWMH', init_tfp_randomwalkmetropolis, .009),\n ]\n for testcase_name, inverse_temperatures, step_size_fn in [\n ('1DTemperatureScalarStep',\n np.float32([1.0, 0.5, 0.25]),\n lambda x: 0.5),\n ('1DTemperature1DStep',\n np.float32([1.0, 0.5, 0.25]),\n lambda x: 0.5 / np.sqrt(x).reshape(3, 1, 1)),\n ('1DTemperature2DStep',\n np.float32([1.0, 0.5, 0.25]),\n lambda x: np.stack( # pylint: disable=g-long-lambda\n [0.5 / np.sqrt(x), 0.5 / np.sqrt(x)],\n axis=-1).reshape(3, 2, 1)),\n ('2DTemperature1DStep',\n np.float32(np.stack([[1.0, 0.5, 0.25], [1.0, 0.25, 0.05]], axis=-1)),\n lambda x: 0.5 / np.sqrt( # pylint: disable=g-long-lambda\n x.mean(axis=-1).reshape(3, 1, 1))),\n ('2DTemperature2DStep',\n np.float32(np.stack([[1.0, 0.5, 0.25], [1.0, 0.25, 0.05]], axis=-1)),\n lambda x: 0.5 / np.sqrt(x).reshape(3, 2, 1))\n ]\n ])\n def test1EventDim2BatchDim3Replica(self,\n tfp_transition_kernel,\n inverse_temperatures,\n step_size_fn,\n ess_scaling):\n \"\"\"Sampling from two batch diagonal multivariate normal.\"\"\"\n step_size = (step_size_fn(inverse_temperatures) +\n np.exp(np.pi) / 100).astype(np.float32) # Prevent resonances.\n\n # Small scale and well-separated modes mean we need replica swap to\n # work or else tests fail.\n loc = np.array(\n [\n # Use 3-D normals, ensuring batch and event sizes don't broadcast.\n [-1., -0.5, 0.], # loc of first batch\n [1., 0.5, 0.], # loc of second batch\n ],\n dtype=np.float32)\n scale_identity_multiplier = [0.5, 0.8]\n target = tfd.MultivariateNormalDiag(\n loc=loc, scale_identity_multiplier=scale_identity_multiplier)\n\n def make_kernel_fn(target_log_prob_fn):\n return tfp_transition_kernel(\n target_log_prob_fn=target_log_prob_fn,\n step_size=step_size,\n num_leapfrog_steps=3)\n\n remc = tfp.mcmc.ReplicaExchangeMC(\n target_log_prob_fn=tf.function(target.log_prob, autograph=False),\n inverse_temperatures=inverse_temperatures,\n make_kernel_fn=make_kernel_fn)\n remc.one_step = tf.function(remc.one_step, autograph=False)\n\n def trace_fn(state, results): # pylint: disable=unused-argument\n return [\n results.post_swap_replica_results.log_accept_ratio,\n results.post_swap_replica_states\n ]\n\n num_results = 2000\n states, (log_accept_ratio, replica_states) = tfp.mcmc.sample_chain(\n num_results=num_results,\n current_state=loc[::-1], # Batch members far from their mode!\n kernel=remc,\n num_burnin_steps=100,\n trace_fn=trace_fn,\n seed=test_util.test_seed())\n\n num_replica = inverse_temperatures.shape[0]\n\n self.assertLen(replica_states, 1) # One state part\n replica_states = replica_states[0]\n\n self.assertAllEqual((num_results, num_replica) + loc.shape,\n replica_states.shape)\n self.assertAllEqual((num_results,) + loc.shape, states.shape)\n\n (\n states_,\n replica_states_,\n replica_mean_,\n replica_cov_,\n accept_probs_,\n ess_,\n ) = self.evaluate([\n states,\n replica_states,\n tf.reduce_mean(replica_states, axis=0),\n tfp.stats.covariance(replica_states),\n tf.math.exp(tf.minimum(0., log_accept_ratio)),\n effective_sample_size(replica_states),\n ])\n\n logging.vlog(\n 2, '---- execution:{} Min[ESS]: {} mean_accept: {}'.format(\n 'eager' if tf.executing_eagerly() else 'graph',\n np.min(ess_), np.mean(accept_probs_, axis=0)))\n\n self.assertAllEqual(states_, replica_states_[:, 0])\n\n def _check_stats(replica_idx, batch_idx, ess_scaling):\n err_msg = 'Failure in replica {}, batch {}'.format(replica_idx, batch_idx)\n assert inverse_temperatures.ndim in [1, 2]\n if inverse_temperatures.ndim == 1:\n temperature = 1 / inverse_temperatures[replica_idx]\n elif inverse_temperatures.ndim == 2:\n temperature = 1 / inverse_temperatures[replica_idx, batch_idx]\n\n expected_scale = (\n scale_identity_multiplier[batch_idx] * np.sqrt(temperature))\n\n ess = np.min(ess_[replica_idx, batch_idx]) # Conservative estimate.\n self.assertGreater(ess, num_results * ess_scaling, msg='Bad sampling!')\n\n self.assertAllClose(\n replica_mean_[replica_idx, batch_idx],\n loc[batch_idx],\n # 6 standard errors of a mean estimate.\n atol=6 * expected_scale / np.sqrt(ess),\n msg=err_msg)\n self.assertAllClose(\n expected_scale**2 * np.eye(loc.shape[1]),\n replica_cov_[replica_idx, batch_idx],\n # 12 standard errors of a variance estimate.\n atol=12 * np.sqrt(2) * expected_scale**2 / np.sqrt(ess),\n msg=err_msg)\n\n for replica_idx in range(num_replica):\n for batch_idx in range(loc.shape[0]):\n _check_stats(replica_idx, batch_idx, ess_scaling)\n\n @parameterized.named_parameters([dict(testcase_name='_slow_asserts',\n asserts=True),\n dict(testcase_name='_fast_execute_only',\n asserts=False)])\n @test_util.numpy_disable_gradient_test('HMC')\n def testMultipleCorrelatedStatesWithOneBatchDim(self, asserts):\n dtype = np.float32\n true_mean = dtype([0, 0])\n true_cov = dtype([[1, 0.5], [0.5, 1]])\n # Use LinearOperatorLowerTriangular to get broadcasting ability.\n linop = tf.linalg.LinearOperatorLowerTriangular(\n tf.linalg.cholesky(true_cov))\n\n def target_log_prob(x, y):\n # Corresponds to unnormalized MVN.\n # z = matmul(inv(chol(true_cov)), [x, y] - true_mean)\n xy = tf.stack([x, y], axis=-1) - true_mean\n z = linop.solvevec(xy)\n return -0.5 * tf.reduce_sum(z**2., axis=-1)\n\n def make_kernel_fn(target_log_prob_fn):\n return tfp.mcmc.HamiltonianMonteCarlo(\n target_log_prob_fn=target_log_prob_fn,\n step_size=[0.75, 0.75],\n num_leapfrog_steps=3)\n\n remc = tfp.mcmc.ReplicaExchangeMC(\n target_log_prob_fn=target_log_prob,\n inverse_temperatures=[1., 0.9, 0.8],\n make_kernel_fn=make_kernel_fn)\n\n num_results = 13\n if asserts:\n num_results = 2000\n remc.one_step = tf.function(remc.one_step, autograph=False)\n\n states = tfp.mcmc.sample_chain(\n num_results=num_results,\n # batch_shape = [4] for each initial state\n current_state=[tf.ones(4), tf.ones(4)],\n kernel=remc,\n num_burnin_steps=400,\n trace_fn=None,\n seed=test_util.test_seed())\n\n states = tf.stack(states, axis=-1)\n self.assertAllEqual((num_results, 4, 2), states.shape)\n\n states_, ess_, cov_ = self.evaluate([\n states,\n effective_sample_size(states),\n tfp.stats.covariance(states)\n ])\n\n if not asserts:\n return\n\n self.assertGreater(np.min(ess_), num_results / 10, 'Bad sampling found!')\n\n # 6 standard errors for mean/variance estimates.\n mean_atol = 6 / np.sqrt(np.min(ess_))\n cov_atol = 6 * np.sqrt(2) / np.sqrt(np.min(ess_))\n\n self.assertAllClose(\n true_mean, states_[:, 0, :].mean(axis=0), atol=mean_atol)\n self.assertAllClose(\n true_mean, states_[:, 1, :].mean(axis=0), atol=mean_atol)\n self.assertAllClose(true_cov, cov_[0], atol=cov_atol)\n self.assertAllClose(true_cov, cov_[1], atol=cov_atol)\n\n def testInversePermutationError(self):\n \"\"\"Using invalid `inverse_temperatures`.\"\"\"\n dtype = np.float32\n def bad_swap_fn(num_replica, batch_shape=(), seed=None): # pylint: disable=unused-argument\n return [1, 2, 0]\n remc = tfp.mcmc.ReplicaExchangeMC(\n target_log_prob_fn=tfd.Normal(loc=dtype(0), scale=dtype(1)).log_prob,\n inverse_temperatures=dtype([1., 0.5, 0.25]),\n make_kernel_fn=lambda tlp: tfp.mcmc.RandomWalkMetropolis( # pylint: disable=g-long-lambda\n target_log_prob_fn=tlp,\n new_state_fn=tfp.mcmc.random_walk_normal_fn(scale=1.)),\n # Fun fact: of the six length-3 permutations, only two are not\n # \"one-time swap\" permutations: [1, 2, 0], [2, 0, 1]\n swap_proposal_fn=bad_swap_fn,\n validate_args=True)\n with self.assertRaisesOpError('must be.*self-inverse permutation'):\n self.evaluate(tfp.mcmc.sample_chain(\n num_results=10,\n num_burnin_steps=2,\n current_state=[dtype(1)],\n kernel=remc,\n trace_fn=None,\n seed=test_util.test_seed()))\n\n def testKernelResultsHaveCorrectShapeWhenMultipleStatesAndBatchDims(self):\n def target_log_prob(x, y):\n xy = tf.concat([x, y], axis=-1)\n return -0.5 * tf.reduce_sum(xy**2, axis=-1)\n\n def make_kernel_fn(target_log_prob_fn):\n return tfp.mcmc.RandomWalkMetropolis(\n target_log_prob_fn=target_log_prob_fn,\n new_state_fn=tfp.mcmc.random_walk_normal_fn(scale=[0.3, 0.1]))\n\n inverse_temperatures = [1., 0.5, 0.25, 0.1]\n remc = tfp.mcmc.ReplicaExchangeMC(\n target_log_prob_fn=target_log_prob,\n inverse_temperatures=inverse_temperatures,\n make_kernel_fn=make_kernel_fn)\n\n num_results = 6\n n_batch = 5\n n_events = 3\n n_states = 2 # Set by target_log_prob.\n num_replica = len(inverse_temperatures)\n\n samples, kernel_results = tfp.mcmc.sample_chain(\n num_results=num_results,\n current_state=[tf.zeros((n_batch, n_events))] * n_states,\n kernel=remc,\n num_burnin_steps=2,\n trace_fn=lambda _, results: results,\n seed=test_util.test_seed())\n\n self.assertLen(samples, n_states)\n self.assertAllEqual((num_results, n_batch, n_events), samples[0].shape)\n self.assertAllEqual((num_results, n_batch, n_events), samples[1].shape)\n\n kr_ = self.evaluate(kernel_results)\n\n # Boring checks of existence/shape.\n self.assertEqual(\n (num_results, num_replica, n_batch, n_states, n_events),\n tf.stack(kr_.post_swap_replica_states, axis=-2).shape)\n\n self.assertEqual(\n (num_results, num_replica, n_batch),\n kr_.pre_swap_replica_results.log_accept_ratio.shape)\n\n self.assertEqual(\n (num_results, num_replica, n_batch),\n kr_.post_swap_replica_results.log_accept_ratio.shape)\n\n self.assertEqual(\n (num_results, num_replica, num_replica, n_batch),\n kr_.is_swap_proposed.shape)\n self.assertEqual(\n (num_results, num_replica, num_replica, n_batch),\n kr_.is_swap_accepted.shape)\n\n self.assertEqual(\n (num_results, num_replica - 1, n_batch),\n kr_.is_swap_proposed_adjacent.shape)\n self.assertEqual(\n (num_results, num_replica - 1, n_batch),\n kr_.is_swap_accepted_adjacent.shape)\n\n self.assertEqual(\n (num_results, num_replica),\n tf.stack(kr_.inverse_temperatures, axis=1).shape)\n\n self.assertEqual(\n (num_results, num_replica, n_batch),\n kr_.swaps.shape)\n\n\nif __name__ == '__main__':\n tf.test.main()\n",
"# Copyright 2018 The TensorFlow Probability 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\"\"\"Local Linear Trend State Space Model Tests.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n# Dependency imports\n\nimport numpy as np\nimport tensorflow.compat.v1 as tf1\nimport tensorflow.compat.v2 as tf\nfrom tensorflow_probability.python import distributions as tfd\nfrom tensorflow_probability.python.internal import test_util\nfrom tensorflow_probability.python.sts import LocalLinearTrendStateSpaceModel\n\n\ntfl = tf.linalg\n\n\nclass _LocalLinearTrendStateSpaceModelTest(object):\n\n def test_logprob(self):\n\n y = self._build_placeholder([1.0, 2.5, 4.3, 6.1, 7.8])\n\n ssm = LocalLinearTrendStateSpaceModel(\n num_timesteps=5,\n level_scale=0.5,\n slope_scale=0.5,\n initial_state_prior=tfd.MultivariateNormalDiag(\n scale_diag=self._build_placeholder([1., 1.])))\n\n lp = ssm.log_prob(y[..., np.newaxis])\n expected_lp = -5.801624298095703\n self.assertAllClose(self.evaluate(lp), expected_lp)\n\n def test_stats(self):\n\n # Build a model with expected initial loc 0 and slope 1.\n level_scale = self._build_placeholder(1.0)\n slope_scale = self._build_placeholder(1.0)\n initial_state_prior = tfd.MultivariateNormalDiag(\n loc=self._build_placeholder([0, 1.]),\n scale_diag=self._build_placeholder([1., 1.]))\n\n ssm = LocalLinearTrendStateSpaceModel(\n num_timesteps=10,\n level_scale=level_scale,\n slope_scale=slope_scale,\n initial_state_prior=initial_state_prior)\n\n # In expectation, the process grows linearly.\n mean = self.evaluate(ssm.mean())\n self.assertAllClose(mean, np.arange(0, 10)[:, np.newaxis])\n\n # slope variance at time T is linear: T * slope_scale\n expected_variance = [1, 3, 8, 18, 35, 61, 98, 148, 213, 295]\n variance = self.evaluate(ssm.variance())\n self.assertAllClose(variance, np.array(expected_variance)[:, np.newaxis])\n\n def test_batch_shape(self):\n batch_shape = [4, 2]\n partial_batch_shape = [2]\n\n level_scale = self._build_placeholder(\n np.exp(np.random.randn(*partial_batch_shape)))\n slope_scale = self._build_placeholder(np.exp(np.random.randn(*batch_shape)))\n initial_state_prior = tfd.MultivariateNormalDiag(\n scale_diag=self._build_placeholder([1., 1.]))\n\n ssm = LocalLinearTrendStateSpaceModel(\n num_timesteps=10,\n level_scale=level_scale,\n slope_scale=slope_scale,\n initial_state_prior=initial_state_prior)\n self.assertAllEqual(self.evaluate(ssm.batch_shape_tensor()), batch_shape)\n\n y = ssm.sample()\n self.assertAllEqual(self.evaluate(tf.shape(y))[:-2], batch_shape)\n\n def _build_placeholder(self, ndarray):\n \"\"\"Convert a numpy array to a TF placeholder.\n\n Args:\n ndarray: any object convertible to a numpy array via `np.asarray()`.\n\n Returns:\n placeholder: a TensorFlow `placeholder` with default value given by the\n provided `ndarray`, dtype given by `self.dtype`, and shape specified\n statically only if `self.use_static_shape` is `True`.\n \"\"\"\n\n ndarray = np.asarray(ndarray).astype(self.dtype)\n return tf1.placeholder_with_default(\n ndarray, shape=ndarray.shape if self.use_static_shape else None)\n\n\n@test_util.test_all_tf_execution_regimes\nclass LocalLinearTrendStateSpaceModelTestStaticShape32(\n test_util.TestCase, _LocalLinearTrendStateSpaceModelTest):\n dtype = np.float32\n use_static_shape = True\n\n\n@test_util.test_all_tf_execution_regimes\nclass LocalLinearTrendStateSpaceModelTestDynamicShape32(\n test_util.TestCase, _LocalLinearTrendStateSpaceModelTest):\n dtype = np.float32\n use_static_shape = False\n\n\n@test_util.test_all_tf_execution_regimes\nclass LocalLinearTrendStateSpaceModelTestStaticShape64(\n test_util.TestCase, _LocalLinearTrendStateSpaceModelTest):\n dtype = np.float64\n use_static_shape = True\n\n\nif __name__ == \"__main__\":\n tf.test.main()\n",
"# Copyright 2018 The TensorFlow Probability 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\"\"\"Tests for random variable.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport re\n\nfrom absl.testing import parameterized\nimport numpy as np\nimport tensorflow.compat.v1 as tf1\nimport tensorflow.compat.v2 as tf\nimport tensorflow_probability as tfp\nfrom tensorflow_probability import edward2 as ed\nfrom tensorflow_probability.python import distributions as tfd\nfrom tensorflow_probability.python.internal import test_util\n\n\nclass FakeDistribution(tfd.Distribution):\n \"\"\"Fake distribution class for testing.\"\"\"\n\n def __init__(self):\n super(FakeDistribution, self).__init__(\n dtype=None,\n reparameterization_type=tfd.FULLY_REPARAMETERIZED,\n validate_args=False,\n allow_nan_stats=True)\n\n\n@test_util.test_all_tf_execution_regimes\nclass RandomVariableTest(test_util.TestCase):\n\n def testConstructor(self):\n x = ed.RandomVariable(tfd.Poisson(rate=tf.ones([2, 5])),\n value=tf.ones([2, 5]))\n x_sample, x_value = self.evaluate([tf.convert_to_tensor(value=x), x.value])\n self.assertAllEqual(x_sample, x_value)\n with self.assertRaises(ValueError):\n _ = ed.RandomVariable(tfd.Bernoulli(probs=0.5),\n value=tf.zeros([2, 5], dtype=tf.int32))\n x = ed.RandomVariable(FakeDistribution())\n with self.assertRaises(NotImplementedError):\n _ = x.value\n\n def testGradientsFirstOrder(self):\n f = lambda x: 2. * x\n x = ed.RandomVariable(tfd.Normal(0., 1.))\n _, dydx = tfp.math.value_and_gradient(f, x)\n self.assertEqual(self.evaluate(dydx), 2.)\n\n def testGradientsSecondOrder(self):\n f = lambda x: 2. * x**2.\n df = lambda x: tfp.math.value_and_gradient(f, x)[1]\n x = ed.RandomVariable(tfd.Normal(0., 1.))\n _, d2ydx2 = tfp.math.value_and_gradient(df, x)\n self.assertEqual(self.evaluate(d2ydx2), 4.)\n\n def testStr(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0), value=1.234)\n if tf.executing_eagerly():\n pattern = \"RandomVariable(\\\"1.234\\\", shape=(), dtype=float32\"\n else:\n pattern = \"RandomVariable(\\\"Normal\\\", shape=(), dtype=float32\"\n regexp = re.escape(pattern)\n self.assertRegexpMatches(str(x), regexp)\n\n def testRepr(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0), value=1.234)\n if tf.executing_eagerly():\n string = (\"<ed.RandomVariable 'Normal' shape=() \"\n \"dtype=float32 numpy=1.234>\")\n else:\n string = \"<ed.RandomVariable 'Normal' shape=() dtype=float32>\"\n self.assertEqual(repr(x), string)\n\n def testNumpy(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0), value=1.23)\n if tf.executing_eagerly():\n self.assertEqual(x.numpy(), tf.constant(1.23).numpy())\n else:\n with self.assertRaises(NotImplementedError):\n _ = x.numpy()\n\n def testOperatorsAdd(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x + y\n z_value = x.value + y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsRadd(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = y + x\n z_value = y + x.value\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsSub(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x - y\n z_value = x.value - y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsRsub(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = y - x\n z_value = y - x.value\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsMul(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x * y\n z_value = x.value * y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsRmul(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = y * x\n z_value = y * x.value\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsDiv(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x / y\n z_value = x.value / y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsRdiv(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = y / x\n z_value = y / x.value\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsFloordiv(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x // y\n z_value = x.value // y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsRfloordiv(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = y // x\n z_value = y // x.value\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsMod(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x % y\n z_value = x.value % y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsRmod(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = y % x\n z_value = y % x.value\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsLt(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x < y\n z_value = x.value < y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsLe(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x <= y\n z_value = x.value <= y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsGt(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x > y\n z_value = x.value > y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsGe(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x >= y\n z_value = x.value >= y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsGetitem(self):\n x = ed.RandomVariable(tfd.Normal(tf.zeros([3, 4]), tf.ones([3, 4])))\n z = x[0:2, 2:3]\n z_value = x.value[0:2, 2:3]\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsPow(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = x ** y\n z_value = x.value ** y\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsRpow(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n z = y ** x\n z_value = y ** x.value\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsNeg(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n z = -x\n z_value = -x.value\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsAbs(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n z = abs(x)\n z_value = abs(x.value)\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testOperatorsHash(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n self.assertNotEqual(hash(x), hash(y))\n self.assertEqual(hash(x), id(x))\n\n def testOperatorsEq(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n self.assertEqual(x, x)\n\n def testOperatorsNe(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = 5.0\n self.assertNotEqual(x, y)\n\n def testOperatorsBoolNonzero(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n with self.assertRaises(TypeError):\n _ = not x\n\n def testArrayPriority(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 1.0))\n y = np.array(5.0, dtype=np.float32)\n z = y / x\n z_value = y / x.value\n z_eval, z_value_eval = self.evaluate([z, z_value])\n self.assertAllEqual(z_eval, z_value_eval)\n\n def testConvertToTensor(self):\n x = ed.RandomVariable(tfd.Normal(0.0, 0.1))\n with self.assertRaises(ValueError):\n _ = tf.convert_to_tensor(value=x, dtype=tf.int32)\n\n def testSessionEval(self):\n if tf.executing_eagerly(): return\n with self.cached_session() as sess:\n x = ed.RandomVariable(tfd.Normal(0.0, 0.1))\n x_ph = tf1.placeholder(tf.float32, [])\n y = ed.RandomVariable(tfd.Normal(x_ph, 0.1))\n self.assertLess(x.eval(), 5.0)\n self.assertLess(x.eval(sess), 5.0)\n self.assertLess(x.eval(feed_dict={x_ph: 100.0}), 5.0)\n self.assertGreater(y.eval(feed_dict={x_ph: 100.0}), 5.0)\n self.assertGreater(y.eval(sess, feed_dict={x_ph: 100.0}), 5.0)\n self.assertRaises(tf.errors.InvalidArgumentError, y.eval)\n self.assertRaises(tf.errors.InvalidArgumentError, y.eval, sess)\n\n def testSessionRun(self):\n if tf.executing_eagerly(): return\n with self.cached_session() as sess:\n x = ed.RandomVariable(tfd.Normal(0.0, 0.1))\n x_ph = tf1.placeholder(tf.float32, [])\n y = ed.RandomVariable(tfd.Normal(x_ph, 0.1))\n self.assertLess(sess.run(x), 5.0)\n self.assertLess(sess.run(x, feed_dict={x_ph: 100.0}), 5.0)\n self.assertGreater(sess.run(y, feed_dict={x_ph: 100.0}), 5.0)\n self.assertRaises(tf.errors.InvalidArgumentError, sess.run, y)\n\n # Note: we must defer creation of any tensors until after tf.test.main().\n # pylint: disable=g-long-lambda\n @parameterized.parameters(\n {\"rv\": lambda: ed.RandomVariable(tfd.Bernoulli(probs=0.5)),\n \"sample_shape\": [],\n \"batch_shape\": [],\n \"event_shape\": []},\n {\"rv\": lambda: ed.RandomVariable(tfd.Bernoulli(tf.zeros([2, 3]))),\n \"sample_shape\": [],\n \"batch_shape\": [2, 3],\n \"event_shape\": []},\n {\"rv\": lambda: ed.RandomVariable(tfd.Bernoulli(probs=0.5),\n sample_shape=2),\n \"sample_shape\": [2],\n \"batch_shape\": [],\n \"event_shape\": []},\n {\"rv\": lambda: ed.RandomVariable(tfd.Bernoulli(probs=0.5),\n sample_shape=[2, 1]),\n \"sample_shape\": [2, 1],\n \"batch_shape\": [],\n \"event_shape\": []},\n {\"rv\": lambda: ed.RandomVariable(tfd.Bernoulli(probs=0.5),\n sample_shape=tf.constant([2])),\n \"sample_shape\": [2],\n \"batch_shape\": [],\n \"event_shape\": []},\n {\"rv\": lambda: ed.RandomVariable(tfd.Bernoulli(probs=0.5),\n sample_shape=tf.constant([2, 4])),\n \"sample_shape\": [2, 4],\n \"batch_shape\": [],\n \"event_shape\": []},\n )\n # pylint: enable=g-long-lambda\n def testShape(self, rv, sample_shape, batch_shape, event_shape):\n rv = rv()\n self.assertEqual(rv.shape, sample_shape + batch_shape + event_shape)\n self.assertEqual(rv.shape, rv.shape)\n self.assertEqual(rv.sample_shape, sample_shape)\n self.assertEqual(rv.distribution.batch_shape, batch_shape)\n self.assertEqual(rv.distribution.event_shape, event_shape)\n\n def testRandomTensorSample(self):\n num_samples = tf.cast(tfd.Poisson(rate=5.).sample(), tf.int32)\n _ = ed.RandomVariable(tfd.Normal(loc=0.0, scale=1.0),\n sample_shape=num_samples)\n\n\nif __name__ == \"__main__\":\n tf.test.main()\n"
] | [
[
"tensorflow.compat.v2.abs",
"tensorflow.compat.v2.TensorShape",
"tensorflow.compat.v2.shape",
"tensorflow.compat.v2.rank",
"tensorflow.compat.v2.zeros_like",
"tensorflow.compat.v2.broadcast_static_shape",
"tensorflow.compat.v2.convert_to_tensor",
"tensorflow.compat.v2.name_scope",
"tensorflow.compat.v2.identity",
"tensorflow.compat.v2.constant"
],
[
"numpy.equal",
"numpy.shape",
"numpy.finfo",
"numpy.abs",
"numpy.issubdtype"
],
[
"numpy.issubdtype"
],
[
"tensorflow.compat.v1.zeros",
"tensorflow.compat.v1.keras.layers.Dense",
"tensorflow.compat.v1.io.gfile.makedirs",
"tensorflow.compat.v1.compat.v2.summary.scalar",
"tensorflow.compat.v1.keras.layers.Conv1D",
"tensorflow.compat.v1.compat.v1.app.run",
"tensorflow.compat.v1.compat.v1.nn.rnn_cell.LSTMCell",
"tensorflow.compat.v1.nn.softplus",
"tensorflow.compat.v1.unstack",
"tensorflow.compat.v1.stack",
"tensorflow.compat.v1.compat.v2.summary.create_file_writer",
"tensorflow.compat.v1.keras.layers.BatchNormalization",
"tensorflow.compat.v1.keras.layers.Dropout",
"tensorflow.compat.v1.cast",
"tensorflow.compat.v1.reduce_mean",
"tensorflow.compat.v1.io.gfile.rmtree",
"tensorflow.compat.v1.io.gfile.exists",
"tensorflow.compat.v1.keras.layers.Activation",
"tensorflow.compat.v1.compat.v1.enable_eager_execution",
"tensorflow.compat.v1.squeeze",
"tensorflow.compat.v1.keras.layers.GlobalAveragePooling1D",
"tensorflow.compat.v1.compat.v1.train.get_or_create_global_step",
"tensorflow.compat.v1.compat.v1.train.AdamOptimizer",
"tensorflow.compat.v1.GradientTape",
"tensorflow.compat.v1.train.Checkpoint",
"tensorflow.compat.v1.math.equal"
],
[
"tensorflow.compat.v2.transpose",
"numpy.log",
"tensorflow.compat.v2.TensorShape",
"numpy.ones",
"tensorflow.compat.v2.ones",
"tensorflow.compat.v2.zeros",
"tensorflow.compat.v2.GradientTape",
"tensorflow.compat.v2.test.main"
],
[
"tensorflow.compat.v2.nest.flatten",
"tensorflow.compat.v2.cast",
"tensorflow.compat.v2.nest.assert_same_structure",
"tensorflow.compat.v2.convert_to_tensor"
],
[
"numpy.minimum",
"tensorflow.compat.v2.linspace",
"numpy.min",
"numpy.mean",
"numpy.exp",
"tensorflow.compat.v2.reduce_sum",
"tensorflow.compat.v2.test.main",
"numpy.max",
"numpy.take",
"numpy.eye",
"tensorflow.compat.v2.function",
"tensorflow.compat.v2.minimum",
"numpy.arange",
"numpy.sqrt",
"tensorflow.compat.v2.stack",
"numpy.transpose",
"numpy.array",
"tensorflow.compat.v2.linalg.cholesky",
"tensorflow.compat.v2.concat",
"tensorflow.compat.v2.ones",
"numpy.float32",
"tensorflow.compat.v2.executing_eagerly",
"tensorflow.compat.v2.random.set_seed",
"numpy.stack",
"tensorflow.compat.v2.constant",
"tensorflow.compat.v2.math.sqrt",
"numpy.sum",
"numpy.ones",
"numpy.any",
"tensorflow.compat.v2.zeros",
"numpy.abs",
"numpy.repeat",
"tensorflow.compat.v2.reduce_mean",
"numpy.var"
],
[
"numpy.array",
"numpy.asarray",
"tensorflow.compat.v2.shape",
"numpy.random.randn",
"numpy.arange",
"tensorflow.compat.v1.placeholder_with_default",
"tensorflow.compat.v2.test.main"
],
[
"tensorflow.compat.v1.placeholder",
"numpy.array",
"tensorflow.compat.v2.ones",
"tensorflow.compat.v2.executing_eagerly",
"tensorflow.compat.v2.zeros",
"tensorflow.compat.v2.convert_to_tensor",
"tensorflow.compat.v2.constant",
"tensorflow.compat.v2.test.main"
]
] |
danielgrassinger/yt_new_frontend | [
"5f91d2fb8721c4c5da0af543a6256ed979cd9fc9",
"5f91d2fb8721c4c5da0af543a6256ed979cd9fc9",
"5f91d2fb8721c4c5da0af543a6256ed979cd9fc9",
"5f91d2fb8721c4c5da0af543a6256ed979cd9fc9"
] | [
"yt/frontends/athena/io.py",
"yt/frontends/tipsy/setup.py",
"yt/units/tests/test_ytarray.py",
"yt/frontends/enzo/data_structures.py"
] | [
"\"\"\"\nThe data-file handling functions\n\n\n\n\"\"\"\n\n#-----------------------------------------------------------------------------\n# Copyright (c) 2013, yt Development Team.\n#\n# Distributed under the terms of the Modified BSD License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n#-----------------------------------------------------------------------------\nfrom yt.utilities.io_handler import \\\n BaseIOHandler\nimport numpy as np\nfrom yt.funcs import mylog, defaultdict\nfrom .data_structures import chk23\n\nfloat_size = {\"float\":np.dtype(\">f4\").itemsize,\n \"double\":np.dtype(\">f8\").itemsize}\n\naxis_list = [\"_x\",\"_y\",\"_z\"]\n\nclass IOHandlerAthena(BaseIOHandler):\n _dataset_type = \"athena\"\n _offset_string = 'data:offsets=0'\n _data_string = 'data:datatype=0'\n _read_table_offset = None\n\n def _field_dict(self,fhandle):\n keys = fhandle['field_types'].keys()\n val = fhandle['field_types'].keys()\n return dict(zip(keys,val))\n\n def _read_field_names(self,grid):\n pass\n\n def _read_chunk_data(self,chunk,fields):\n data = {}\n if len(chunk.objs) == 0: return data\n for grid in chunk.objs:\n if grid.filename is None:\n continue\n f = open(grid.filename, \"rb\")\n data[grid.id] = {}\n grid_dims = grid.ActiveDimensions\n read_dims = grid.read_dims.astype(\"int64\")\n grid_ncells = np.prod(read_dims)\n grid0_ncells = np.prod(grid.index.grids[0].read_dims)\n read_table_offset = get_read_table_offset(f)\n for field in fields:\n ftype, offsetr, dtype = grid.index._field_map[field]\n if grid_ncells != grid0_ncells:\n offset = offsetr + ((grid_ncells-grid0_ncells) * (offsetr//grid0_ncells))\n if grid_ncells == grid0_ncells:\n offset = offsetr\n offset = int(offset) # Casting to be certain.\n file_offset = grid.file_offset[2]*read_dims[0]*read_dims[1]*float_size[dtype]\n xread = slice(grid.file_offset[0],grid.file_offset[0]+grid_dims[0])\n yread = slice(grid.file_offset[1],grid.file_offset[1]+grid_dims[1])\n f.seek(read_table_offset+offset+file_offset)\n if dtype == 'float':\n dt = '>f4'\n elif dtype == 'double':\n dt = '>f8'\n if ftype == 'scalar':\n f.seek(read_table_offset+offset+file_offset)\n v = np.fromfile(f, dtype=dt,\n count=grid_ncells).reshape(read_dims,order='F')\n if ftype == 'vector':\n vec_offset = axis_list.index(field[-1][-2:])\n f.seek(read_table_offset+offset+3*file_offset)\n v = np.fromfile(f, dtype=dt, count=3*grid_ncells)\n v = v[vec_offset::3].reshape(read_dims,order='F')\n if grid.ds.field_ordering == 1:\n data[grid.id][field] = v[xread,yread,:].T.astype(\"float64\")\n else:\n data[grid.id][field] = v[xread,yread,:].astype(\"float64\")\n f.close()\n return data\n \n def _read_data_slice(self, grid, field, axis, coord):\n sl = [slice(None), slice(None), slice(None)]\n sl[axis] = slice(coord, coord + 1)\n if grid.ds.field_ordering == 1:\n sl.reverse()\n return self._read_data_set(grid, field)[sl]\n\n def _read_fluid_selection(self, chunks, selector, fields, size):\n chunks = list(chunks)\n if any((ftype != \"athena\" for ftype, fname in fields)):\n raise NotImplementedError\n rv = {}\n for field in fields:\n rv[field] = np.empty(size, dtype=\"float64\")\n ng = sum(len(c.objs) for c in chunks)\n mylog.debug(\"Reading %s cells of %s fields in %s grids\",\n size, [f2 for f1, f2 in fields], ng)\n ind = 0\n for chunk in chunks:\n data = self._read_chunk_data(chunk, fields)\n for g in chunk.objs:\n for field in fields:\n ftype, fname = field\n ds = data[g.id].pop(field)\n nd = g.select(selector, ds, rv[field], ind) # caches\n ind += nd\n data.pop(g.id)\n return rv\n\ndef get_read_table_offset(f):\n line = f.readline()\n while True:\n splitup = line.strip().split()\n chkc = chk23('CELL_DATA')\n chkp = chk23('POINT_DATA')\n if chkc in splitup or chkp in splitup:\n f.readline()\n read_table_offset = f.tell()\n break\n line = f.readline()\n return read_table_offset\n\n\n",
"#!/usr/bin/env python\nimport setuptools\nimport os\nimport sys\nimport os.path\n\n\ndef configuration(parent_package='', top_path=None):\n from numpy.distutils.misc_util import Configuration\n config = Configuration('tipsy', parent_package, top_path)\n config.make_config_py() # installs __config__.py\n #config.make_svn_version_py()\n return config\n",
"\"\"\"\nTest ndarray subclass that handles symbolic units.\n\n\n\n\n\"\"\"\n\n# ----------------------------------------------------------------------------\n# Copyright (c) 2013, yt Development Team.\n#\n# Distributed under the terms of the Modified BSD License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n# ----------------------------------------------------------------------------\n\nimport copy\nfrom yt.extern.six.moves import cPickle as pickle\nimport itertools\nimport numpy as np\nimport operator\nimport os\nimport shutil\nimport tempfile\n\nfrom nose.tools import assert_true\nfrom numpy.testing import \\\n assert_array_equal, \\\n assert_equal, assert_raises, \\\n assert_array_almost_equal_nulp, \\\n assert_array_almost_equal\nfrom numpy import array\nfrom yt.units.yt_array import \\\n YTArray, YTQuantity, \\\n unary_operators, binary_operators, \\\n uconcatenate, uintersect1d, \\\n uunion1d\nfrom yt.utilities.exceptions import \\\n YTUnitOperationError, YTUfuncUnitError\nfrom yt.testing import \\\n fake_random_ds, requires_module, \\\n assert_allclose_units\nfrom yt.funcs import fix_length\nfrom yt.units.unit_symbols import \\\n cm, m, g\nfrom yt.utilities.physical_ratios import \\\n metallicity_sun\n\ndef operate_and_compare(a, b, op, answer):\n # Test generator for YTArrays tests\n assert_array_equal(op(a, b), answer)\n\n\ndef assert_isinstance(a, type):\n assert isinstance(a, type)\n\n\ndef test_addition():\n \"\"\"\n Test addition of two YTArrays\n\n \"\"\"\n\n # Same units\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = YTArray([4, 5, 6], 'cm')\n a3 = [4*cm, 5*cm, 6*cm]\n answer = YTArray([5, 7, 9], 'cm')\n\n yield operate_and_compare, a1, a2, operator.add, answer\n yield operate_and_compare, a2, a1, operator.add, answer\n yield operate_and_compare, a1, a3, operator.add, answer\n yield operate_and_compare, a3, a1, operator.add, answer\n yield operate_and_compare, a2, a1, np.add, answer\n yield operate_and_compare, a1, a2, np.add, answer\n yield operate_and_compare, a1, a3, np.add, answer\n yield operate_and_compare, a3, a1, np.add, answer\n\n # different units\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = YTArray([4, 5, 6], 'm')\n a3 = [4*m, 5*m, 6*m]\n answer1 = YTArray([401, 502, 603], 'cm')\n answer2 = YTArray([4.01, 5.02, 6.03], 'm')\n\n yield operate_and_compare, a1, a2, operator.add, answer1\n yield operate_and_compare, a2, a1, operator.add, answer2\n yield operate_and_compare, a1, a3, operator.add, answer1\n yield operate_and_compare, a3, a1, operator.add, answer1\n yield assert_raises, YTUfuncUnitError, np.add, a1, a2\n yield assert_raises, YTUfuncUnitError, np.add, a1, a3\n\n # Test dimensionless quantities\n a1 = YTArray([1, 2, 3])\n a2 = array([4, 5, 6])\n a3 = [4, 5, 6]\n answer = YTArray([5, 7, 9])\n\n yield operate_and_compare, a1, a2, operator.add, answer\n yield operate_and_compare, a2, a1, operator.add, answer\n yield operate_and_compare, a1, a3, operator.add, answer\n yield operate_and_compare, a3, a1, operator.add, answer\n yield operate_and_compare, a1, a2, np.add, answer\n yield operate_and_compare, a2, a1, np.add, answer\n yield operate_and_compare, a1, a3, np.add, answer\n yield operate_and_compare, a3, a1, np.add, answer\n\n # Catch the different dimensions error\n a1 = YTArray([1, 2, 3], 'm')\n a2 = YTArray([4, 5, 6], 'kg')\n\n yield assert_raises, YTUnitOperationError, operator.add, a1, a2\n yield assert_raises, YTUnitOperationError, operator.iadd, a1, a2\n\n\ndef test_subtraction():\n \"\"\"\n Test subtraction of two YTArrays\n\n \"\"\"\n\n # Same units\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = YTArray([4, 5, 6], 'cm')\n a3 = [4*cm, 5*cm, 6*cm]\n answer1 = YTArray([-3, -3, -3], 'cm')\n answer2 = YTArray([3, 3, 3], 'cm')\n\n yield operate_and_compare, a1, a2, operator.sub, answer1\n yield operate_and_compare, a2, a1, operator.sub, answer2\n yield operate_and_compare, a1, a3, operator.sub, answer1\n yield operate_and_compare, a3, a1, operator.sub, answer2\n yield operate_and_compare, a1, a2, np.subtract, answer1\n yield operate_and_compare, a2, a1, np.subtract, answer2\n yield operate_and_compare, a1, a3, np.subtract, answer1\n yield operate_and_compare, a3, a1, np.subtract, answer2\n\n # different units\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = YTArray([4, 5, 6], 'm')\n a3 = [4*m, 5*m, 6*m]\n answer1 = YTArray([-399, -498, -597], 'cm')\n answer2 = YTArray([3.99, 4.98, 5.97], 'm')\n answer3 = YTArray([399, 498, 597], 'cm')\n\n yield operate_and_compare, a1, a2, operator.sub, answer1\n yield operate_and_compare, a2, a1, operator.sub, answer2\n yield operate_and_compare, a1, a3, operator.sub, answer1\n yield operate_and_compare, a3, a1, operator.sub, answer3\n yield assert_raises, YTUfuncUnitError, np.subtract, a1, a2\n yield assert_raises, YTUfuncUnitError, np.subtract, a1, a3\n\n # Test dimensionless quantities\n a1 = YTArray([1, 2, 3])\n a2 = array([4, 5, 6])\n a3 = [4, 5, 6]\n answer1 = YTArray([-3, -3, -3])\n answer2 = YTArray([3, 3, 3])\n\n yield operate_and_compare, a1, a2, operator.sub, answer1\n yield operate_and_compare, a2, a1, operator.sub, answer2\n yield operate_and_compare, a1, a3, operator.sub, answer1\n yield operate_and_compare, a3, a1, operator.sub, answer2\n yield operate_and_compare, a1, a2, np.subtract, answer1\n yield operate_and_compare, a2, a1, np.subtract, answer2\n yield operate_and_compare, a1, a3, np.subtract, answer1\n yield operate_and_compare, a3, a1, np.subtract, answer2\n\n # Catch the different dimensions error\n a1 = YTArray([1, 2, 3], 'm')\n a2 = YTArray([4, 5, 6], 'kg')\n\n yield assert_raises, YTUnitOperationError, operator.sub, a1, a2\n yield assert_raises, YTUnitOperationError, operator.isub, a1, a2\n\n\ndef test_multiplication():\n \"\"\"\n Test multiplication of two YTArrays\n\n \"\"\"\n\n # Same units\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = YTArray([4, 5, 6], 'cm')\n a3 = [4*cm, 5*cm, 6*cm]\n answer = YTArray([4, 10, 18], 'cm**2')\n\n yield operate_and_compare, a1, a2, operator.mul, answer\n yield operate_and_compare, a2, a1, operator.mul, answer\n yield operate_and_compare, a1, a3, operator.mul, answer\n yield operate_and_compare, a3, a1, operator.mul, answer\n yield operate_and_compare, a1, a2, np.multiply, answer\n yield operate_and_compare, a2, a1, np.multiply, answer\n yield operate_and_compare, a1, a3, np.multiply, answer\n yield operate_and_compare, a3, a1, np.multiply, answer\n\n # different units, same dimension\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = YTArray([4, 5, 6], 'm')\n a3 = [4*m, 5*m, 6*m]\n answer1 = YTArray([400, 1000, 1800], 'cm**2')\n answer2 = YTArray([.04, .10, .18], 'm**2')\n answer3 = YTArray([4, 10, 18], 'cm*m')\n\n yield operate_and_compare, a1, a2, operator.mul, answer1\n yield operate_and_compare, a2, a1, operator.mul, answer2\n yield operate_and_compare, a1, a3, operator.mul, answer1\n yield operate_and_compare, a3, a1, operator.mul, answer2\n yield operate_and_compare, a1, a2, np.multiply, answer3\n yield operate_and_compare, a2, a1, np.multiply, answer3\n yield operate_and_compare, a1, a3, np.multiply, answer3\n yield operate_and_compare, a3, a1, np.multiply, answer3\n\n # different dimensions\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = YTArray([4, 5, 6], 'g')\n a3 = [4*g, 5*g, 6*g]\n answer = YTArray([4, 10, 18], 'cm*g')\n\n yield operate_and_compare, a1, a2, operator.mul, answer\n yield operate_and_compare, a2, a1, operator.mul, answer\n yield operate_and_compare, a1, a3, operator.mul, answer\n yield operate_and_compare, a3, a1, operator.mul, answer\n yield operate_and_compare, a1, a2, np.multiply, answer\n yield operate_and_compare, a2, a1, np.multiply, answer\n yield operate_and_compare, a1, a3, np.multiply, answer\n yield operate_and_compare, a3, a1, np.multiply, answer\n\n # One dimensionless, one unitful\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = array([4, 5, 6])\n a3 = [4, 5, 6]\n answer = YTArray([4, 10, 18], 'cm')\n\n yield operate_and_compare, a1, a2, operator.mul, answer\n yield operate_and_compare, a2, a1, operator.mul, answer\n yield operate_and_compare, a1, a3, operator.mul, answer\n yield operate_and_compare, a3, a1, operator.mul, answer\n yield operate_and_compare, a1, a2, np.multiply, answer\n yield operate_and_compare, a2, a1, np.multiply, answer\n yield operate_and_compare, a1, a3, np.multiply, answer\n yield operate_and_compare, a3, a1, np.multiply, answer\n\n # Both dimensionless quantities\n a1 = YTArray([1, 2, 3])\n a2 = array([4, 5, 6])\n a3 = [4, 5, 6]\n answer = YTArray([4, 10, 18])\n\n yield operate_and_compare, a1, a2, operator.mul, answer\n yield operate_and_compare, a2, a1, operator.mul, answer\n yield operate_and_compare, a1, a3, operator.mul, answer\n yield operate_and_compare, a3, a1, operator.mul, answer\n yield operate_and_compare, a1, a2, np.multiply, answer\n yield operate_and_compare, a2, a1, np.multiply, answer\n yield operate_and_compare, a1, a3, np.multiply, answer\n yield operate_and_compare, a3, a1, np.multiply, answer\n\n\ndef test_division():\n \"\"\"\n Test multiplication of two YTArrays\n\n \"\"\"\n\n # Same units\n a1 = YTArray([1., 2., 3.], 'cm')\n a2 = YTArray([4., 5., 6.], 'cm')\n a3 = [4*cm, 5*cm, 6*cm]\n answer1 = YTArray([0.25, 0.4, 0.5])\n answer2 = YTArray([4, 2.5, 2])\n if \"div\" in dir(operator):\n op = operator.div\n else:\n op = operator.truediv\n\n yield operate_and_compare, a1, a2, op, answer1\n yield operate_and_compare, a2, a1, op, answer2\n yield operate_and_compare, a1, a3, op, answer1\n yield operate_and_compare, a3, a1, op, answer2\n yield operate_and_compare, a1, a2, np.divide, answer1\n yield operate_and_compare, a2, a1, np.divide, answer2\n yield operate_and_compare, a1, a3, np.divide, answer1\n yield operate_and_compare, a3, a1, np.divide, answer2\n\n # different units, same dimension\n a1 = YTArray([1., 2., 3.], 'cm')\n a2 = YTArray([4., 5., 6.], 'm')\n a3 = [4*m, 5*m, 6*m]\n answer1 = YTArray([.0025, .004, .005])\n answer2 = YTArray([400, 250, 200])\n answer3 = YTArray([0.25, 0.4, 0.5], 'cm/m')\n answer4 = YTArray([4.0, 2.5, 2.0], 'm/cm')\n\n yield operate_and_compare, a1, a2, op, answer1\n yield operate_and_compare, a2, a1, op, answer2\n yield operate_and_compare, a1, a3, op, answer1\n yield operate_and_compare, a3, a1, op, answer2\n yield operate_and_compare, a1, a2, np.divide, answer3\n yield operate_and_compare, a2, a1, np.divide, answer4\n yield operate_and_compare, a1, a3, np.divide, answer3\n yield operate_and_compare, a3, a1, np.divide, answer4\n\n # different dimensions\n a1 = YTArray([1., 2., 3.], 'cm')\n a2 = YTArray([4., 5., 6.], 'g')\n a3 = [4*g, 5*g, 6*g]\n answer1 = YTArray([0.25, 0.4, 0.5], 'cm/g')\n answer2 = YTArray([4, 2.5, 2], 'g/cm')\n\n yield operate_and_compare, a1, a2, op, answer1\n yield operate_and_compare, a2, a1, op, answer2\n yield operate_and_compare, a1, a3, op, answer1\n yield operate_and_compare, a3, a1, op, answer2\n yield operate_and_compare, a1, a2, np.divide, answer1\n yield operate_and_compare, a2, a1, np.divide, answer2\n yield operate_and_compare, a1, a3, np.divide, answer1\n yield operate_and_compare, a3, a1, np.divide, answer2\n\n # One dimensionless, one unitful\n a1 = YTArray([1., 2., 3.], 'cm')\n a2 = array([4., 5., 6.])\n a3 = [4, 5, 6]\n answer1 = YTArray([0.25, 0.4, 0.5], 'cm')\n answer2 = YTArray([4, 2.5, 2], '1/cm')\n\n yield operate_and_compare, a1, a2, op, answer1\n yield operate_and_compare, a2, a1, op, answer2\n yield operate_and_compare, a1, a3, op, answer1\n yield operate_and_compare, a3, a1, op, answer2\n yield operate_and_compare, a1, a2, np.divide, answer1\n yield operate_and_compare, a2, a1, np.divide, answer2\n yield operate_and_compare, a1, a3, np.divide, answer1\n yield operate_and_compare, a3, a1, np.divide, answer2\n\n # Both dimensionless quantities\n a1 = YTArray([1., 2., 3.])\n a2 = array([4., 5., 6.])\n a3 = [4, 5, 6]\n answer1 = YTArray([0.25, 0.4, 0.5])\n answer2 = YTArray([4, 2.5, 2])\n\n yield operate_and_compare, a1, a2, op, answer1\n yield operate_and_compare, a2, a1, op, answer2\n yield operate_and_compare, a1, a3, op, answer1\n yield operate_and_compare, a3, a1, op, answer2\n yield operate_and_compare, a1, a3, np.divide, answer1\n yield operate_and_compare, a3, a1, np.divide, answer2\n yield operate_and_compare, a1, a3, np.divide, answer1\n yield operate_and_compare, a3, a1, np.divide, answer2\n\n\ndef test_power():\n \"\"\"\n Test power operator ensure units are correct.\n\n \"\"\"\n\n from yt.units import cm\n\n cm_arr = np.array([1.0, 1.0]) * cm\n\n assert_equal, cm**3, YTQuantity(1, 'cm**3')\n assert_equal, np.power(cm, 3), YTQuantity(1, 'cm**3')\n assert_equal, cm**YTQuantity(3), YTQuantity(1, 'cm**3')\n assert_raises, YTUnitOperationError, np.power, cm, YTQuantity(3, 'g')\n\n assert_equal, cm_arr**3, YTArray([1, 1], 'cm**3')\n assert_equal, np.power(cm_arr, 3), YTArray([1, 1], 'cm**3')\n assert_equal, cm_arr**YTQuantity(3), YTArray([1, 1], 'cm**3')\n assert_raises, YTUnitOperationError, np.power, cm_arr, YTQuantity(3, 'g')\n\n\ndef test_comparisons():\n \"\"\"\n Test numpy ufunc comparison operators for unit consistency.\n\n \"\"\"\n from yt.units.yt_array import YTArray\n\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = YTArray([2, 1, 3], 'cm')\n a3 = YTArray([.02, .01, .03], 'm')\n\n ops = (\n np.less,\n np.less_equal,\n np.greater,\n np.greater_equal,\n np.equal,\n np.not_equal\n )\n\n answers = (\n [True, False, False],\n [True, False, True],\n [False, True, False],\n [False, True, True],\n [False, False, True],\n [True, True, False],\n )\n\n for op, answer in zip(ops, answers):\n yield operate_and_compare, a1, a2, op, answer\n\n for op in ops:\n yield assert_raises, YTUfuncUnitError, op, a1, a3\n\n for op, answer in zip(ops, answers):\n yield operate_and_compare, a1, a3.in_units('cm'), op, answer\n\n\ndef test_unit_conversions():\n \"\"\"\n Test operations that convert to different units or cast to ndarray\n\n \"\"\"\n from yt.units.yt_array import YTQuantity\n from yt.units.unit_object import Unit\n\n km = YTQuantity(1, 'km')\n km_in_cm = km.in_units('cm')\n cm_unit = Unit('cm')\n kpc_unit = Unit('kpc')\n\n yield assert_equal, km_in_cm, km\n yield assert_equal, km_in_cm.in_cgs(), 1e5\n yield assert_equal, km_in_cm.in_mks(), 1e3\n yield assert_equal, km_in_cm.units, cm_unit\n\n km_view = km.ndarray_view()\n km.convert_to_units('cm')\n assert_true(km_view.base is km.base)\n\n yield assert_equal, km, YTQuantity(1, 'km')\n yield assert_equal, km.in_cgs(), 1e5\n yield assert_equal, km.in_mks(), 1e3\n yield assert_equal, km.units, cm_unit\n\n km.convert_to_units('kpc')\n assert_true(km_view.base is km.base)\n\n yield assert_array_almost_equal_nulp, km, YTQuantity(1, 'km')\n yield assert_array_almost_equal_nulp, km.in_cgs(), YTQuantity(1e5, 'cm')\n yield assert_array_almost_equal_nulp, km.in_mks(), YTQuantity(1e3, 'm')\n yield assert_equal, km.units, kpc_unit\n\n yield assert_isinstance, km.to_ndarray(), np.ndarray\n yield assert_isinstance, km.ndarray_view(), np.ndarray\n\n dyne = YTQuantity(1.0, 'dyne')\n\n yield assert_equal, dyne.in_cgs(), dyne\n yield assert_equal, dyne.in_cgs(), 1.0\n yield assert_equal, dyne.in_mks(), dyne\n yield assert_equal, dyne.in_mks(), 1e-5\n yield assert_equal, str(dyne.in_mks().units), 'kg*m/s**2'\n yield assert_equal, str(dyne.in_cgs().units), 'cm*g/s**2'\n\n em3 = YTQuantity(1.0, 'erg/m**3')\n\n yield assert_equal, em3.in_cgs(), em3\n yield assert_equal, em3.in_cgs(), 1e-6\n yield assert_equal, em3.in_mks(), em3\n yield assert_equal, em3.in_mks(), 1e-7\n yield assert_equal, str(em3.in_mks().units), 'kg/(m*s**2)'\n yield assert_equal, str(em3.in_cgs().units), 'g/(cm*s**2)'\n\ndef test_temperature_conversions():\n \"\"\"\n Test conversions between various supported temperatue scales.\n\n Also ensure we only allow compound units with temperature\n scales that have a proper zero point.\n\n \"\"\"\n from yt.units.unit_object import InvalidUnitOperation\n\n km = YTQuantity(1, 'km')\n balmy = YTQuantity(300, 'K')\n balmy_F = YTQuantity(80.33, 'degF')\n balmy_C = YTQuantity(26.85, 'degC')\n balmy_R = YTQuantity(540, 'R')\n\n assert_array_almost_equal(balmy.in_units('degF'), balmy_F)\n assert_array_almost_equal(balmy.in_units('degC'), balmy_C)\n assert_array_almost_equal(balmy.in_units('R'), balmy_R)\n\n balmy_view = balmy.ndarray_view()\n\n balmy.convert_to_units('degF')\n yield assert_true, balmy_view.base is balmy.base\n yield assert_array_almost_equal, np.array(balmy), np.array(balmy_F)\n\n balmy.convert_to_units('degC')\n yield assert_true, balmy_view.base is balmy.base\n yield assert_array_almost_equal, np.array(balmy), np.array(balmy_C)\n\n balmy.convert_to_units('R')\n yield assert_true, balmy_view.base is balmy.base\n yield assert_array_almost_equal, np.array(balmy), np.array(balmy_R)\n\n balmy.convert_to_units('degF')\n yield assert_true, balmy_view.base is balmy.base\n yield assert_array_almost_equal, np.array(balmy), np.array(balmy_F)\n\n yield assert_raises, InvalidUnitOperation, np.multiply, balmy, km\n\n # Does CGS conversion from F to K work?\n yield assert_array_almost_equal, balmy.in_cgs(), YTQuantity(300, 'K')\n\n\ndef test_yt_array_yt_quantity_ops():\n \"\"\"\n Test operations that combine YTArray and YTQuantity\n \"\"\"\n a = YTArray(range(10), 'cm')\n b = YTQuantity(5, 'g')\n\n yield assert_isinstance, a*b, YTArray\n yield assert_isinstance, b*a, YTArray\n\n yield assert_isinstance, a/b, YTArray\n yield assert_isinstance, b/a, YTArray\n\n yield assert_isinstance, a*a, YTArray\n yield assert_isinstance, a/a, YTArray\n\n yield assert_isinstance, b*b, YTQuantity\n yield assert_isinstance, b/b, YTQuantity\n\n\ndef test_selecting():\n \"\"\"\n Test slicing of two YTArrays\n\n \"\"\"\n a = YTArray(range(10), 'cm')\n a_slice = a[:3]\n a_fancy_index = a[[1, 1, 3, 5]]\n a_array_fancy_index = a[array([[1, 1], [3, 5]])]\n a_boolean_index = a[a > 5]\n a_selection = a[0]\n\n yield assert_array_equal, a_slice, YTArray([0, 1, 2], 'cm')\n yield assert_array_equal, a_fancy_index, YTArray([1, 1, 3, 5], 'cm')\n yield assert_array_equal, a_array_fancy_index, \\\n YTArray([[1, 1, ], [3, 5]], 'cm')\n yield assert_array_equal, a_boolean_index, YTArray([6, 7, 8, 9], 'cm')\n yield assert_isinstance, a_selection, YTQuantity\n\n # .base points to the original array for a numpy view. If it is not a\n # view, .base is None.\n yield assert_true, a_slice.base is a\n\n\ndef test_fix_length():\n \"\"\"\n Test fixing the length of an array. Used in spheres and other data objects\n \"\"\"\n ds = fake_random_ds(64, nprocs=1, length_unit=10)\n length = ds.quan(1.0, 'code_length')\n new_length = fix_length(length, ds=ds)\n yield assert_equal, YTQuantity(10, 'cm'), new_length\n\n\ndef test_ytarray_pickle():\n ds = fake_random_ds(64, nprocs=1)\n test_data = [ds.quan(12.0, 'code_length'),\n ds.arr([1, 2, 3], 'code_length')]\n\n for data in test_data:\n tempf = tempfile.NamedTemporaryFile(delete=False)\n pickle.dump(data, tempf)\n tempf.close()\n\n with open(tempf.name, \"rb\") as fname:\n loaded_data = pickle.load(fname)\n os.unlink(tempf.name)\n\n yield assert_array_equal, data, loaded_data\n yield assert_equal, data.units, loaded_data.units\n yield assert_array_equal, array(data.in_cgs()), \\\n array(loaded_data.in_cgs())\n yield assert_equal, float(data.units.base_value), \\\n float(loaded_data.units.base_value)\n\n\ndef test_copy():\n quan = YTQuantity(1, 'g')\n arr = YTArray([1, 2, 3], 'cm')\n\n yield assert_equal, copy.copy(quan), quan\n yield assert_array_equal, copy.copy(arr), arr\n\n yield assert_equal, copy.deepcopy(quan), quan\n yield assert_array_equal, copy.deepcopy(arr), arr\n\n yield assert_equal, quan.copy(), quan\n yield assert_array_equal, arr.copy(), arr\n\n yield assert_equal, np.copy(quan), quan\n yield assert_array_equal, np.copy(arr), arr\n\n\ndef unary_ufunc_comparison(ufunc, a):\n out = a.copy()\n a_array = a.to_ndarray()\n if ufunc in (np.isreal, np.iscomplex, ):\n # According to the numpy docs, these two explicitly do not do\n # in-place copies.\n ret = ufunc(a)\n assert_true(not hasattr(ret, 'units'))\n assert_array_equal(ret, ufunc(a))\n elif ufunc in (np.exp, np.exp2, np.log, np.log2, np.log10, np.expm1,\n np.log1p, np.sin, np.cos, np.tan, np.arcsin, np.arccos,\n np.arctan, np.sinh, np.cosh, np.tanh, np.arccosh,\n np.arcsinh, np.arctanh, np.deg2rad, np.rad2deg,\n np.isfinite, np.isinf, np.isnan, np.signbit, np.sign,\n np.rint, np.logical_not):\n # These operations should return identical results compared to numpy.\n\n try:\n ret = ufunc(a, out=out)\n except YTUnitOperationError:\n assert_true(ufunc in (np.deg2rad, np.rad2deg))\n ret = ufunc(YTArray(a, '1'))\n\n assert_array_equal(ret, out)\n assert_array_equal(ret, ufunc(a_array))\n # In-place copies do not drop units.\n assert_true(hasattr(out, 'units'))\n assert_true(not hasattr(ret, 'units'))\n elif ufunc in (np.absolute, np.fabs, np.conjugate, np.floor, np.ceil,\n np.trunc, np.negative):\n ret = ufunc(a, out=out)\n\n assert_array_equal(ret, out)\n assert_array_equal(ret.to_ndarray(), ufunc(a_array))\n assert_true(ret.units == out.units)\n elif ufunc in (np.ones_like, np.square, np.sqrt, np.reciprocal):\n if ufunc is np.ones_like:\n ret = ufunc(a)\n else:\n ret = ufunc(a, out=out)\n assert_array_equal(ret, out)\n\n assert_array_equal(ret.to_ndarray(), ufunc(a_array))\n if ufunc is np.square:\n assert_true(out.units == a.units**2)\n assert_true(ret.units == a.units**2)\n elif ufunc is np.sqrt:\n assert_true(out.units == a.units**0.5)\n assert_true(ret.units == a.units**0.5)\n elif ufunc is np.reciprocal:\n assert_true(out.units == a.units**-1)\n assert_true(ret.units == a.units**-1)\n elif ufunc is np.modf:\n ret1, ret2 = ufunc(a)\n npret1, npret2 = ufunc(a_array)\n\n assert_array_equal(ret1.to_ndarray(), npret1)\n assert_array_equal(ret2.to_ndarray(), npret2)\n elif ufunc is np.frexp:\n ret1, ret2 = ufunc(a)\n npret1, npret2 = ufunc(a_array)\n\n assert_array_equal(ret1, npret1)\n assert_array_equal(ret2, npret2)\n else:\n # There shouldn't be any untested ufuncs.\n assert_true(False)\n\n\ndef binary_ufunc_comparison(ufunc, a, b):\n out = a.copy()\n if ufunc in (np.add, np.subtract, np.remainder, np.fmod, np.mod,\n np.arctan2, np.hypot, np.greater, np.greater_equal, np.less,\n np.less_equal, np.equal, np.not_equal, np.logical_and,\n np.logical_or, np.logical_xor, np.maximum, np.minimum,\n np.fmax, np.fmin, np.nextafter):\n if a.units != b.units and a.units.dimensions == b.units.dimensions:\n assert_raises(YTUfuncUnitError, ufunc, a, b)\n return\n elif a.units != b.units:\n assert_raises(YTUnitOperationError, ufunc, a, b)\n return\n\n ret = ufunc(a, b, out=out)\n\n if ufunc is np.multiply:\n assert_true(ret.units == a.units*b.units)\n elif ufunc in (np.divide, np.true_divide, np.arctan2):\n assert_true(ret.units.dimensions == (a.units/b.units).dimensions)\n elif ufunc in (np.greater, np.greater_equal, np.less, np.less_equal,\n np.not_equal, np.equal, np.logical_and, np.logical_or,\n np.logical_xor):\n assert_true(not isinstance(ret, YTArray) and\n isinstance(ret, np.ndarray))\n assert_array_equal(ret, out)\n if (ufunc in (np.divide, np.true_divide, np.arctan2) and\n (a.units.dimensions == b.units.dimensions)):\n assert_array_almost_equal(\n np.array(ret), ufunc(np.array(a.in_cgs()), np.array(b.in_cgs())))\n else:\n assert_array_almost_equal(np.array(ret), ufunc(np.array(a), np.array(b)))\n\n\ndef test_ufuncs():\n for ufunc in unary_operators:\n yield unary_ufunc_comparison, ufunc, YTArray([.3, .4, .5], 'cm')\n yield unary_ufunc_comparison, ufunc, YTArray([12, 23, 47], 'g')\n yield unary_ufunc_comparison, ufunc, YTArray([2, 4, -6], 'erg/m**3')\n\n for ufunc in binary_operators:\n\n # arr**arr is undefined for arrays with units because\n # each element of the result would have different units.\n if ufunc is np.power:\n a = YTArray([.3, .4, .5], 'cm')\n b = YTArray([.1, .2, .3], 'dimensionless')\n c = np.array(b)\n yield binary_ufunc_comparison, ufunc, a, b\n yield binary_ufunc_comparison, ufunc, a, c\n continue\n\n a = YTArray([.3, .4, .5], 'cm')\n b = YTArray([.1, .2, .3], 'cm')\n c = YTArray([.1, .2, .3], 'm')\n d = YTArray([.1, .2, .3], 'g')\n e = YTArray([.1, .2, .3], 'erg/m**3')\n\n for pair in itertools.product([a, b, c, d, e], repeat=2):\n yield binary_ufunc_comparison, ufunc, pair[0], pair[1]\n\n\ndef test_convenience():\n\n arr = YTArray([1, 2, 3], 'cm')\n\n yield assert_equal, arr.unit_quantity, YTQuantity(1, 'cm')\n yield assert_equal, arr.uq, YTQuantity(1, 'cm')\n yield assert_isinstance, arr.unit_quantity, YTQuantity\n yield assert_isinstance, arr.uq, YTQuantity\n\n yield assert_array_equal, arr.unit_array, YTArray(np.ones_like(arr), 'cm')\n yield assert_array_equal, arr.ua, YTArray(np.ones_like(arr), 'cm')\n yield assert_isinstance, arr.unit_array, YTArray\n yield assert_isinstance, arr.ua, YTArray\n\n yield assert_array_equal, arr.ndview, arr.view(np.ndarray)\n yield assert_array_equal, arr.d, arr.view(np.ndarray)\n yield assert_true, arr.ndview.base is arr.base\n yield assert_true, arr.d.base is arr.base\n\n yield assert_array_equal, arr.value, np.array(arr)\n yield assert_array_equal, arr.v, np.array(arr)\n\n\ndef test_registry_association():\n ds = fake_random_ds(64, nprocs=1, length_unit=10)\n a = ds.quan(3, 'cm')\n b = YTQuantity(4, 'm')\n c = ds.quan(6, '')\n d = 5\n\n yield assert_equal, id(a.units.registry), id(ds.unit_registry)\n\n def binary_op_registry_comparison(op):\n e = op(a, b)\n f = op(b, a)\n g = op(c, d)\n h = op(d, c)\n\n assert_equal(id(e.units.registry), id(ds.unit_registry))\n assert_equal(id(f.units.registry), id(b.units.registry))\n assert_equal(id(g.units.registry), id(h.units.registry))\n assert_equal(id(g.units.registry), id(ds.unit_registry))\n\n def unary_op_registry_comparison(op):\n c = op(a)\n d = op(b)\n\n assert_equal(id(c.units.registry), id(ds.unit_registry))\n assert_equal(id(d.units.registry), id(b.units.registry))\n\n binary_ops = [operator.add, operator.sub, operator.mul, \n operator.truediv]\n if hasattr(operator, \"div\"):\n binary_ops.append(operator.div)\n for op in binary_ops:\n yield binary_op_registry_comparison, op\n\n for op in [operator.abs, operator.neg, operator.pos]:\n yield unary_op_registry_comparison, op\n\n@requires_module(\"astropy\")\ndef test_astropy():\n from yt.utilities.on_demand_imports import _astropy\n\n ap_arr = np.arange(10)*_astropy.units.km/_astropy.units.hr\n yt_arr = YTArray(np.arange(10), \"km/hr\")\n yt_arr2 = YTArray.from_astropy(ap_arr)\n\n ap_quan = 10.*_astropy.units.Msun**0.5/(_astropy.units.kpc**3)\n yt_quan = YTQuantity(10., \"sqrt(Msun)/kpc**3\")\n yt_quan2 = YTQuantity.from_astropy(ap_quan)\n\n yield assert_array_equal, ap_arr, yt_arr.to_astropy()\n yield assert_array_equal, yt_arr, YTArray.from_astropy(ap_arr)\n yield assert_array_equal, yt_arr, yt_arr2\n\n yield assert_equal, ap_quan, yt_quan.to_astropy()\n yield assert_equal, yt_quan, YTQuantity.from_astropy(ap_quan)\n yield assert_equal, yt_quan, yt_quan2\n\n yield assert_array_equal, yt_arr, YTArray.from_astropy(yt_arr.to_astropy())\n yield assert_equal, yt_quan, YTQuantity.from_astropy(yt_quan.to_astropy())\n\ndef test_subclass():\n\n class YTASubclass(YTArray):\n pass\n\n a = YTASubclass([4, 5, 6], 'g')\n b = YTASubclass([7, 8, 9], 'kg')\n nu = YTASubclass([10, 11, 12], '')\n nda = np.array([3, 4, 5])\n yta = YTArray([6, 7, 8], 'mg')\n loq = [YTQuantity(6, 'mg'), YTQuantity(7, 'mg'), YTQuantity(8, 'mg')]\n ytq = YTQuantity(4, 'cm')\n ndf = np.float64(3)\n\n def op_comparison(op, inst1, inst2, compare_class):\n assert_isinstance(op(inst1, inst2), compare_class)\n assert_isinstance(op(inst2, inst1), compare_class)\n\n ops = [operator.mul, operator.truediv]\n if hasattr(operator, \"div\"):\n ops.append(operator.div)\n for op in ops:\n for inst in (b, ytq, ndf, yta, nda, loq):\n yield op_comparison, op, a, inst, YTASubclass\n\n yield op_comparison, op, ytq, nda, YTArray\n yield op_comparison, op, ytq, yta, YTArray\n\n for op in (operator.add, operator.sub):\n yield op_comparison, op, nu, nda, YTASubclass\n yield op_comparison, op, a, b, YTASubclass\n yield op_comparison, op, a, yta, YTASubclass\n yield op_comparison, op, a, loq, YTASubclass\n\n yield assert_isinstance, a[0], YTQuantity\n yield assert_isinstance, a[:], YTASubclass\n yield assert_isinstance, a[:2], YTASubclass\n\ndef test_h5_io():\n tmpdir = tempfile.mkdtemp()\n curdir = os.getcwd()\n os.chdir(tmpdir)\n\n ds = fake_random_ds(64, nprocs=1, length_unit=10)\n\n warr = ds.arr(np.random.random((256, 256)), 'code_length')\n\n warr.write_hdf5('test.h5')\n\n iarr = YTArray.from_hdf5('test.h5')\n\n yield assert_equal, warr, iarr\n yield assert_equal, warr.units.registry['code_length'], iarr.units.registry['code_length']\n\n os.chdir(curdir)\n shutil.rmtree(tmpdir)\n\ndef test_equivalencies():\n from yt.utilities.physical_constants import clight, mp, kboltz, hcgs, mh, me, \\\n mass_sun_cgs, G, stefan_boltzmann_constant_cgs\n import yt.units as u\n\n # Mass-energy\n\n E = mp.to_equivalent(\"keV\",\"mass_energy\")\n yield assert_equal, E, mp*clight*clight\n yield assert_allclose_units, mp, E.to_equivalent(\"g\", \"mass_energy\")\n\n # Thermal\n\n T = YTQuantity(1.0e8,\"K\")\n E = T.to_equivalent(\"W*hr\",\"thermal\")\n yield assert_equal, E, (kboltz*T).in_units(\"W*hr\")\n yield assert_allclose_units, T, E.to_equivalent(\"K\", \"thermal\")\n\n # Spectral\n\n l = YTQuantity(4000.,\"angstrom\")\n nu = l.to_equivalent(\"Hz\",\"spectral\")\n yield assert_equal, nu, clight/l\n E = hcgs*nu\n l2 = E.to_equivalent(\"angstrom\", \"spectral\")\n yield assert_allclose_units, l, l2\n nu2 = clight/l2.in_units(\"cm\")\n yield assert_allclose_units, nu, nu2\n E2 = nu2.to_equivalent(\"keV\", \"spectral\")\n yield assert_allclose_units, E2, E.in_units(\"keV\")\n\n # Sound-speed\n\n mu = 0.6\n gg = 5./3.\n c_s = T.to_equivalent(\"km/s\",\"sound_speed\")\n yield assert_equal, c_s, np.sqrt(gg*kboltz*T/(mu*mh))\n yield assert_allclose_units, T, c_s.to_equivalent(\"K\",\"sound_speed\")\n\n mu = 0.5\n gg = 4./3.\n c_s = T.to_equivalent(\"km/s\",\"sound_speed\", mu=mu, gamma=gg)\n yield assert_equal, c_s, np.sqrt(gg*kboltz*T/(mu*mh))\n yield assert_allclose_units, T, c_s.to_equivalent(\"K\",\"sound_speed\",\n mu=mu, gamma=gg)\n\n # Lorentz\n\n v = 0.8*clight\n g = v.to_equivalent(\"dimensionless\",\"lorentz\")\n g2 = YTQuantity(1./np.sqrt(1.-0.8*0.8), \"dimensionless\")\n yield assert_allclose_units, g, g2\n v2 = g2.to_equivalent(\"mile/hr\", \"lorentz\")\n yield assert_allclose_units, v2, v.in_units(\"mile/hr\")\n\n # Schwarzschild\n\n R = mass_sun_cgs.to_equivalent(\"kpc\",\"schwarzschild\")\n yield assert_equal, R.in_cgs(), 2*G*mass_sun_cgs/(clight*clight)\n yield assert_allclose_units, mass_sun_cgs, R.to_equivalent(\"g\", \"schwarzschild\")\n\n # Compton\n\n l = me.to_equivalent(\"angstrom\",\"compton\")\n yield assert_equal, l, hcgs/(me*clight)\n yield assert_allclose_units, me, l.to_equivalent(\"g\", \"compton\")\n\n # Number density\n\n rho = mp/u.cm**3\n\n n = rho.to_equivalent(\"cm**-3\",\"number_density\")\n yield assert_equal, n, rho/(mh*0.6)\n yield assert_allclose_units, rho, n.to_equivalent(\"g/cm**3\",\"number_density\")\n\n n = rho.to_equivalent(\"cm**-3\",\"number_density\", mu=0.75)\n yield assert_equal, n, rho/(mh*0.75)\n yield assert_allclose_units, rho, n.to_equivalent(\"g/cm**3\",\"number_density\", mu=0.75)\n\n # Effective temperature\n\n T = YTQuantity(1.0e4, \"K\")\n F = T.to_equivalent(\"erg/s/cm**2\",\"effective_temperature\")\n yield assert_equal, F, stefan_boltzmann_constant_cgs*T**4\n yield assert_allclose_units, T, F.to_equivalent(\"K\", \"effective_temperature\")\n\ndef test_electromagnetic():\n from yt.units.dimensions import charge_mks, pressure, current_cgs, \\\n magnetic_field_mks, magnetic_field_cgs, power\n from yt.utilities.physical_constants import mu_0, qp\n from yt.utilities.physical_ratios import speed_of_light_cm_per_s\n\n # Various tests of SI and CGS electromagnetic units\n\n qp_mks = qp.to_equivalent(\"C\", \"SI\")\n yield assert_equal, qp_mks.units.dimensions, charge_mks\n yield assert_array_almost_equal, qp_mks.v, 10.0*qp.v/speed_of_light_cm_per_s\n\n qp_cgs = qp_mks.to_equivalent(\"esu\", \"CGS\")\n yield assert_array_almost_equal, qp_cgs, qp\n yield assert_equal, qp_cgs.units.dimensions, qp.units.dimensions\n \n qp_mks_k = qp.to_equivalent(\"kC\", \"SI\")\n yield assert_array_almost_equal, qp_mks_k.v, 1.0e-2*qp.v/speed_of_light_cm_per_s\n\n B = YTQuantity(1.0, \"T\")\n B_cgs = B.to_equivalent(\"gauss\", \"CGS\")\n yield assert_equal, B.units.dimensions, magnetic_field_mks\n yield assert_equal, B_cgs.units.dimensions, magnetic_field_cgs\n yield assert_array_almost_equal, B_cgs, YTQuantity(1.0e4, \"gauss\")\n\n u_mks = B*B/(2*mu_0)\n yield assert_equal, u_mks.units.dimensions, pressure\n u_cgs = B_cgs*B_cgs/(8*np.pi)\n yield assert_equal, u_cgs.units.dimensions, pressure\n yield assert_array_almost_equal, u_mks.in_cgs(), u_cgs\n \n I = YTQuantity(1.0, \"A\")\n I_cgs = I.to_equivalent(\"statA\", \"CGS\")\n yield assert_array_almost_equal, I_cgs, YTQuantity(0.1*speed_of_light_cm_per_s, \"statA\")\n yield assert_array_almost_equal, I_cgs.to_equivalent(\"mA\", \"SI\"), I.in_units(\"mA\")\n yield assert_equal, I_cgs.units.dimensions, current_cgs\n \n R = YTQuantity(1.0, \"ohm\")\n R_cgs = R.to_equivalent(\"statohm\", \"CGS\")\n P_mks = I*I*R\n P_cgs = I_cgs*I_cgs*R_cgs\n yield assert_equal, P_mks.units.dimensions, power\n yield assert_equal, P_cgs.units.dimensions, power\n yield assert_array_almost_equal, P_cgs.in_cgs(), P_mks.in_cgs()\n yield assert_array_almost_equal, P_cgs.in_mks(), YTQuantity(1.0, \"W\")\n \n V = YTQuantity(1.0, \"statV\")\n V_mks = V.to_equivalent(\"V\", \"SI\")\n yield assert_array_almost_equal, V_mks.v, 1.0e8*V.v/speed_of_light_cm_per_s\n\ndef test_ytarray_coercion():\n a = YTArray([1, 2, 3], 'cm')\n q = YTQuantity(3, 'cm')\n na = np.array([1, 2, 3])\n\n assert_isinstance(a*q, YTArray)\n assert_isinstance(q*na, YTArray)\n assert_isinstance(q*3, YTQuantity)\n assert_isinstance(q*np.float64(3), YTQuantity)\n assert_isinstance(q*np.array(3), YTQuantity)\n\ndef test_numpy_wrappers():\n a1 = YTArray([1, 2, 3], 'cm')\n a2 = YTArray([2, 3, 4, 5, 6], 'cm')\n catenate_answer = [1, 2, 3, 2, 3, 4, 5, 6]\n intersect_answer = [2, 3]\n union_answer = [1, 2, 3, 4, 5, 6]\n\n yield (assert_array_equal, YTArray(catenate_answer, 'cm'),\n uconcatenate((a1, a2)))\n yield assert_array_equal, catenate_answer, np.concatenate((a1, a2))\n\n yield (assert_array_equal, YTArray(intersect_answer, 'cm'),\n uintersect1d(a1, a2))\n yield assert_array_equal, intersect_answer, np.intersect1d(a1, a2)\n\n yield assert_array_equal, YTArray(union_answer, 'cm'), uunion1d(a1, a2)\n yield assert_array_equal, union_answer, np.union1d(a1, a2)\n\ndef test_dimensionless_conversion():\n a = YTQuantity(1, 'Zsun')\n b = a.in_units('Zsun')\n a.convert_to_units('Zsun')\n yield assert_true, a.units.base_value == metallicity_sun\n yield assert_true, b.units.base_value == metallicity_sun\n\ndef test_modified_unit_division():\n ds1 = fake_random_ds(64)\n ds2 = fake_random_ds(64)\n\n # this mocks comoving coordinates without going through the trouble\n # of setting up a fake cosmological dataset\n ds1.unit_registry.modify('m', 50)\n\n a = ds1.quan(3, 'm')\n b = ds2.quan(3, 'm')\n\n ret = a/b\n yield assert_true, ret == 0.5\n yield assert_true, ret.units.is_dimensionless\n yield assert_true, ret.units.base_value == 1.0\n",
"\"\"\"\nData structures for Enzo\n\n\n\n\"\"\"\n\n#-----------------------------------------------------------------------------\n# Copyright (c) 2013, yt Development Team.\n#\n# Distributed under the terms of the Modified BSD License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n#-----------------------------------------------------------------------------\n\nimport h5py\nimport weakref\nimport numpy as np\nimport os\nimport stat\nimport string\nimport re\n\nfrom threading import Thread\n\nfrom yt.extern.six.moves import zip as izip\n\nfrom yt.funcs import *\nfrom yt.config import ytcfg\nfrom yt.data_objects.grid_patch import \\\n AMRGridPatch\nfrom yt.geometry.grid_geometry_handler import \\\n GridIndex\nfrom yt.geometry.geometry_handler import \\\n YTDataChunk\nfrom yt.data_objects.static_output import \\\n Dataset\nfrom yt.fields.field_info_container import \\\n FieldInfoContainer, NullFunc\nfrom yt.utilities.definitions import \\\n mpc_conversion, sec_conversion\nfrom yt.utilities.physical_constants import \\\n rho_crit_g_cm3_h2, cm_per_mpc\nfrom yt.utilities.io_handler import io_registry\nfrom yt.utilities.logger import ytLogger as mylog\nfrom yt.utilities.pyparselibconfig import libconfig\n\nfrom .fields import \\\n EnzoFieldInfo\n\nfrom yt.utilities.parallel_tools.parallel_analysis_interface import \\\n parallel_blocking_call\n\nclass EnzoGrid(AMRGridPatch):\n \"\"\"\n Class representing a single Enzo Grid instance.\n \"\"\"\n\n def __init__(self, id, index):\n \"\"\"\n Returns an instance of EnzoGrid with *id*, associated with\n *filename* and *index*.\n \"\"\"\n #All of the field parameters will be passed to us as needed.\n AMRGridPatch.__init__(self, id, filename = None, index = index)\n self._children_ids = []\n self._parent_id = -1\n self.Level = -1\n\n def _guess_properties_from_parent(self):\n \"\"\"\n We know that our grid boundary occurs on the cell boundary of our\n parent. This can be a very expensive process, but it is necessary\n in some indexs, where yt is unable to generate a completely\n space-filling tiling of grids, possibly due to the finite accuracy in a\n standard Enzo index file.\n \"\"\"\n rf = self.ds.refine_by\n my_ind = self.id - self._id_offset\n le = self.LeftEdge\n self.dds = self.Parent.dds/rf\n ParentLeftIndex = np.rint((self.LeftEdge-self.Parent.LeftEdge)/self.Parent.dds)\n self.start_index = rf*(ParentLeftIndex + self.Parent.get_global_startindex()).astype('int64')\n self.LeftEdge = self.Parent.LeftEdge + self.Parent.dds * ParentLeftIndex\n self.RightEdge = self.LeftEdge + self.ActiveDimensions*self.dds\n self.index.grid_left_edge[my_ind,:] = self.LeftEdge\n self.index.grid_right_edge[my_ind,:] = self.RightEdge\n self._child_mask = None\n self._child_index_mask = None\n self._child_indices = None\n self._setup_dx()\n\n def set_filename(self, filename):\n \"\"\"\n Intelligently set the filename.\n \"\"\"\n if filename is None:\n self.filename = filename\n return\n if self.index._strip_path:\n self.filename = os.path.join(self.index.directory,\n os.path.basename(filename))\n elif filename[0] == os.path.sep:\n self.filename = filename\n else:\n self.filename = os.path.join(self.index.directory, filename)\n return\n\n def __repr__(self):\n return \"EnzoGrid_%04i\" % (self.id)\n\n @property\n def Parent(self):\n if self._parent_id == -1: return None\n return self.index.grids[self._parent_id - self._id_offset]\n\n @property\n def Children(self):\n return [self.index.grids[cid - self._id_offset]\n for cid in self._children_ids]\n\n @property\n def NumberOfActiveParticles(self):\n if not hasattr(self.index, \"grid_active_particle_count\"): return {}\n id = self.id - self._id_offset\n nap = dict((ptype, self.index.grid_active_particle_count[ptype][id]) \\\n for ptype in self.index.grid_active_particle_count)\n return nap\n\nclass EnzoGridInMemory(EnzoGrid):\n __slots__ = ['proc_num']\n def set_filename(self, filename):\n pass\n\nclass EnzoGridGZ(EnzoGrid):\n\n __slots__ = ()\n\n def retrieve_ghost_zones(self, n_zones, fields, all_levels=False,\n smoothed=False):\n NGZ = self.ds.parameters.get(\"NumberOfGhostZones\", 3)\n if n_zones > NGZ:\n return EnzoGrid.retrieve_ghost_zones(\n self, n_zones, fields, all_levels, smoothed)\n\n # ----- Below is mostly the original code, except we remove the field\n # ----- access section\n # We will attempt this by creating a datacube that is exactly bigger\n # than the grid by nZones*dx in each direction\n nl = self.get_global_startindex() - n_zones\n nr = nl + self.ActiveDimensions + 2*n_zones\n new_left_edge = nl * self.dds + self.ds.domain_left_edge\n new_right_edge = nr * self.dds + self.ds.domain_left_edge\n # Something different needs to be done for the root grid, though\n level = self.Level\n args = (level, new_left_edge, new_right_edge)\n kwargs = {'dims': self.ActiveDimensions + 2*n_zones,\n 'num_ghost_zones':n_zones,\n 'use_pbar':False}\n # This should update the arguments to set the field parameters to be\n # those of this grid.\n kwargs.update(self.field_parameters)\n if smoothed:\n #cube = self.index.smoothed_covering_grid(\n # level, new_left_edge, new_right_edge, **kwargs)\n cube = self.index.smoothed_covering_grid(\n level, new_left_edge, **kwargs)\n else:\n cube = self.index.covering_grid(\n level, new_left_edge, **kwargs)\n # ----- This is EnzoGrid.get_data, duplicated here mostly for\n # ---- efficiency's sake.\n start_zone = NGZ - n_zones\n if start_zone == 0:\n end_zone = None\n else:\n end_zone = -(NGZ - n_zones)\n sl = [slice(start_zone, end_zone) for i in range(3)]\n if fields is None: return cube\n for field in ensure_list(fields):\n if field in self.field_list:\n conv_factor = 1.0\n if field in self.ds.field_info:\n conv_factor = self.ds.field_info[field]._convert_function(self)\n if self.ds.field_info[field].particle_type: continue\n temp = self.index.io._read_raw_data_set(self, field)\n temp = temp.swapaxes(0, 2)\n cube.field_data[field] = np.multiply(temp, conv_factor, temp)[sl]\n return cube\n\nclass EnzoHierarchy(GridIndex):\n\n _strip_path = False\n grid = EnzoGrid\n _preload_implemented = True\n\n def __init__(self, ds, dataset_type):\n\n self.dataset_type = dataset_type\n if ds.file_style != None:\n self._bn = ds.file_style\n else:\n self._bn = \"%s.cpu%%04i\"\n self.index_filename = os.path.abspath(\n \"%s.hierarchy\" % (ds.parameter_filename))\n if os.path.getsize(self.index_filename) == 0:\n raise IOError(-1,\"File empty\", self.index_filename)\n self.directory = os.path.dirname(self.index_filename)\n\n # For some reason, r8 seems to want Float64\n if \"CompilerPrecision\" in ds \\\n and ds[\"CompilerPrecision\"] == \"r4\":\n self.float_type = 'float32'\n else:\n self.float_type = 'float64'\n\n GridIndex.__init__(self, ds, dataset_type)\n # sync it back\n self.dataset.dataset_type = self.dataset_type\n\n def _count_grids(self):\n self.num_grids = None\n test_grid = test_grid_id = None\n self.num_stars = 0\n for line in rlines(open(self.index_filename, \"rb\")):\n if line.startswith(\"BaryonFileName\") or \\\n line.startswith(\"ParticleFileName\") or \\\n line.startswith(\"FileName \"):\n test_grid = line.split(\"=\")[-1].strip().rstrip()\n if line.startswith(\"NumberOfStarParticles\"):\n self.num_stars = int(line.split(\"=\")[-1])\n if line.startswith(\"Grid \"):\n if self.num_grids is None:\n self.num_grids = int(line.split(\"=\")[-1])\n test_grid_id = int(line.split(\"=\")[-1])\n if test_grid is not None:\n break\n self._guess_dataset_type(self.ds.dimensionality, test_grid, test_grid_id)\n\n def _guess_dataset_type(self, rank, test_grid, test_grid_id):\n if test_grid[0] != os.path.sep:\n test_grid = os.path.join(self.directory, test_grid)\n if not os.path.exists(test_grid):\n test_grid = os.path.join(self.directory,\n os.path.basename(test_grid))\n mylog.debug(\"Your data uses the annoying hardcoded path.\")\n self._strip_path = True\n if self.dataset_type is not None: return\n if rank == 3:\n mylog.debug(\"Detected packed HDF5\")\n if self.parameters.get(\"WriteGhostZones\", 0) == 1:\n self.dataset_type= \"enzo_packed_3d_gz\"\n self.grid = EnzoGridGZ\n else:\n self.dataset_type = 'enzo_packed_3d'\n elif rank == 2:\n mylog.debug(\"Detect packed 2D\")\n self.dataset_type = 'enzo_packed_2d'\n elif rank == 1:\n mylog.debug(\"Detect packed 1D\")\n self.dataset_type = 'enzo_packed_1d'\n else:\n raise NotImplementedError\n\n # Sets are sorted, so that won't work!\n def _parse_index(self):\n def _next_token_line(token, f):\n for line in f:\n if line.startswith(token):\n return line.split()[2:]\n t1 = time.time()\n pattern = r\"Pointer: Grid\\[(\\d*)\\]->NextGrid(Next|This)Level = (\\d*)\\s+$\"\n patt = re.compile(pattern)\n f = open(self.index_filename, \"rt\")\n self.grids = [self.grid(1, self)]\n self.grids[0].Level = 0\n si, ei, LE, RE, fn, npart = [], [], [], [], [], []\n all = [si, ei, LE, RE, fn]\n pbar = get_pbar(\"Parsing Hierarchy \", self.num_grids)\n version = self.dataset.parameters.get(\"VersionNumber\", None)\n params = self.dataset.parameters\n if version is None and \"Internal\" in params:\n version = float(params[\"Internal\"][\"Provenance\"][\"VersionNumber\"])\n if version >= 3.0:\n active_particles = True\n nap = dict((ap_type, []) for ap_type in \n params[\"Physics\"][\"ActiveParticles\"][\"ActiveParticlesEnabled\"])\n elif version == 2.2:\n active_particles = True\n nap = {}\n for type in self.parameters.get(\"AppendActiveParticleType\", []):\n nap[type] = []\n else:\n active_particles = False\n nap = None\n for grid_id in range(self.num_grids):\n pbar.update(grid_id)\n # We will unroll this list\n si.append(_next_token_line(\"GridStartIndex\", f))\n ei.append(_next_token_line(\"GridEndIndex\", f))\n LE.append(_next_token_line(\"GridLeftEdge\", f))\n RE.append(_next_token_line(\"GridRightEdge\", f))\n nb = int(_next_token_line(\"NumberOfBaryonFields\", f)[0])\n fn.append([None])\n if nb > 0: fn[-1] = _next_token_line(\"BaryonFileName\", f)\n npart.append(int(_next_token_line(\"NumberOfParticles\", f)[0]))\n # Below we find out what active particles exist in this grid,\n # and add their counts individually.\n if active_particles:\n ptypes = _next_token_line(\"PresentParticleTypes\", f)\n counts = [int(c) for c in _next_token_line(\"ParticleTypeCounts\", f)]\n for ptype in self.parameters.get(\"AppendActiveParticleType\", []):\n if ptype in ptypes:\n nap[ptype].append(counts[ptypes.index(ptype)])\n else:\n nap[ptype].append(0)\n if nb == 0 and npart[-1] > 0: fn[-1] = _next_token_line(\"ParticleFileName\", f)\n for line in f:\n if len(line) < 2: break\n if line.startswith(\"Pointer:\"):\n vv = patt.findall(line)[0]\n self.__pointer_handler(vv)\n pbar.finish()\n self._fill_arrays(ei, si, LE, RE, npart, nap)\n temp_grids = np.empty(self.num_grids, dtype='object')\n temp_grids[:] = self.grids\n self.grids = temp_grids\n self.filenames = fn\n t2 = time.time()\n\n def _initialize_grid_arrays(self):\n super(EnzoHierarchy, self)._initialize_grid_arrays()\n if \"AppendActiveParticleType\" in self.parameters.keys() and \\\n len(self.parameters[\"AppendActiveParticleType\"]):\n gac = dict((ptype, np.zeros(self.num_grids, dtype='i4')) \\\n for ptype in self.parameters[\"AppendActiveParticleType\"])\n self.grid_active_particle_count = gac\n\n def _fill_arrays(self, ei, si, LE, RE, npart, nap):\n self.grid_dimensions.flat[:] = ei\n self.grid_dimensions -= np.array(si, dtype='i4')\n self.grid_dimensions += 1\n self.grid_left_edge.flat[:] = LE\n self.grid_right_edge.flat[:] = RE\n self.grid_particle_count.flat[:] = npart\n if nap is not None:\n for ptype in nap:\n self.grid_active_particle_count[ptype].flat[:] = nap[ptype]\n\n def __pointer_handler(self, m):\n sgi = int(m[2])-1\n if sgi == -1: return # if it's 0, then we're done with that lineage\n # Okay, so, we have a pointer. We make a new grid, with an id of the length+1\n # (recall, Enzo grids are 1-indexed)\n self.grids.append(self.grid(len(self.grids)+1, self))\n # We'll just go ahead and make a weakref to cache\n second_grid = self.grids[sgi] # zero-indexed already\n first_grid = self.grids[int(m[0])-1]\n if m[1] == \"Next\":\n first_grid._children_ids.append(second_grid.id)\n second_grid._parent_id = first_grid.id\n second_grid.Level = first_grid.Level + 1\n elif m[1] == \"This\":\n if first_grid.Parent is not None:\n first_grid.Parent._children_ids.append(second_grid.id)\n second_grid._parent_id = first_grid._parent_id\n second_grid.Level = first_grid.Level\n self.grid_levels[sgi] = second_grid.Level\n\n def _rebuild_top_grids(self, level = 0):\n mylog.info(\"Rebuilding grids on level %s\", level)\n cmask = (self.grid_levels.flat == (level + 1))\n cmsum = cmask.sum()\n mask = np.zeros(self.num_grids, dtype='bool')\n for grid in self.select_grids(level):\n mask[:] = 0\n LE = self.grid_left_edge[grid.id - grid._id_offset]\n RE = self.grid_right_edge[grid.id - grid._id_offset]\n grids, grid_i = self.get_box_grids(LE, RE)\n mask[grid_i] = 1\n grid._children_ids = []\n cgrids = self.grids[ ( mask * cmask).astype('bool') ]\n mylog.info(\"%s: %s / %s\", grid, len(cgrids), cmsum)\n for cgrid in cgrids:\n grid._children_ids.append(cgrid.id)\n cgrid._parent_id = grid.id\n mylog.info(\"Finished rebuilding\")\n\n def _populate_grid_objects(self):\n reconstruct = ytcfg.getboolean(\"yt\",\"reconstruct_index\")\n for g,f in izip(self.grids, self.filenames):\n g._prepare_grid()\n g._setup_dx()\n g.set_filename(f[0])\n if reconstruct:\n if g.Parent is not None: g._guess_properties_from_parent()\n del self.filenames # No longer needed.\n self.max_level = self.grid_levels.max()\n\n def _detect_active_particle_fields(self):\n ap_list = self.dataset[\"AppendActiveParticleType\"]\n _fields = dict((ap, []) for ap in ap_list)\n fields = []\n for ptype in self.dataset[\"AppendActiveParticleType\"]:\n select_grids = self.grid_active_particle_count[ptype].flat\n if np.any(select_grids) == False:\n current_ptypes = self.dataset.particle_types\n new_ptypes = [p for p in current_ptypes if p != ptype]\n self.dataset.particle_types = new_ptypes\n self.dataset.particle_types_raw = new_ptypes\n continue\n gs = self.grids[select_grids > 0]\n g = gs[0]\n handle = h5py.File(g.filename, \"r\")\n node = handle[\"/Grid%08i/Particles/\" % g.id]\n for ptype in (str(p) for p in node):\n if ptype not in _fields: continue\n for field in (str(f) for f in node[ptype]):\n _fields[ptype].append(field)\n fields += [(ptype, field) for field in _fields.pop(ptype)]\n handle.close()\n return set(fields)\n\n def _setup_derived_fields(self):\n super(EnzoHierarchy, self)._setup_derived_fields()\n aps = self.dataset.parameters.get(\n \"AppendActiveParticleType\", [])\n for fname, field in self.ds.field_info.items():\n if not field.particle_type: continue\n if isinstance(fname, tuple): continue\n if field._function is NullFunc: continue\n for apt in aps:\n dd = field._copy_def()\n dd.pop(\"name\")\n self.ds.field_info.add_field((apt, fname), **dd)\n\n def _detect_output_fields(self):\n self.field_list = []\n # Do this only on the root processor to save disk work.\n if self.comm.rank in (0, None):\n mylog.info(\"Gathering a field list (this may take a moment.)\")\n field_list = set()\n random_sample = self._generate_random_grids()\n for grid in random_sample:\n if not hasattr(grid, 'filename'): continue\n try:\n gf = self.io._read_field_names(grid)\n except self.io._read_exception:\n raise IOError(\"Grid %s is a bit funky?\", grid.id)\n mylog.debug(\"Grid %s has: %s\", grid.id, gf)\n field_list = field_list.union(gf)\n if \"AppendActiveParticleType\" in self.dataset.parameters:\n ap_fields = self._detect_active_particle_fields()\n field_list = list(set(field_list).union(ap_fields))\n ptypes = self.dataset.particle_types\n ptypes_raw = self.dataset.particle_types_raw\n else:\n field_list = None\n ptypes = None\n ptypes_raw = None\n self.field_list = list(self.comm.mpi_bcast(field_list))\n self.dataset.particle_types = list(self.comm.mpi_bcast(ptypes))\n self.dataset.particle_types_raw = list(self.comm.mpi_bcast(ptypes_raw))\n\n\n def _generate_random_grids(self):\n if self.num_grids > 40:\n starter = np.random.randint(0, 20)\n random_sample = np.mgrid[starter:len(self.grids)-1:20j].astype(\"int32\")\n # We also add in a bit to make sure that some of the grids have\n # particles\n gwp = self.grid_particle_count > 0\n if np.any(gwp) and not np.any(gwp[(random_sample,)]):\n # We just add one grid. This is not terribly efficient.\n first_grid = np.where(gwp)[0][0]\n random_sample.resize((21,))\n random_sample[-1] = first_grid\n mylog.debug(\"Added additional grid %s\", first_grid)\n mylog.debug(\"Checking grids: %s\", random_sample.tolist())\n else:\n random_sample = np.mgrid[0:max(len(self.grids),1)].astype(\"int32\")\n return self.grids[(random_sample,)]\n\n def find_particles_by_type(self, ptype, max_num=None, additional_fields=None):\n \"\"\"\n Returns a structure of arrays with all of the particles'\n positions, velocities, masses, types, IDs, and attributes for\n a particle type **ptype** for a maximum of **max_num**\n particles. If non-default particle fields are used, provide\n them in **additional_fields**.\n \"\"\"\n # Not sure whether this routine should be in the general HierarchyType.\n if self.grid_particle_count.sum() == 0:\n mylog.info(\"Data contains no particles.\");\n return None\n if additional_fields is None:\n additional_fields = ['metallicity_fraction', 'creation_time',\n 'dynamical_time']\n pfields = [f for f in self.field_list if f.startswith('particle_')]\n nattr = self.dataset['NumberOfParticleAttributes']\n if nattr > 0:\n pfields += additional_fields[:nattr]\n # Find where the particles reside and count them\n if max_num is None: max_num = 1e100\n total = 0\n pstore = []\n for level in range(self.max_level, -1, -1):\n for grid in self.select_grids(level):\n index = np.where(grid['particle_type'] == ptype)[0]\n total += len(index)\n pstore.append(index)\n if total >= max_num: break\n if total >= max_num: break\n result = None\n if total > 0:\n result = {}\n for p in pfields:\n result[p] = np.zeros(total, 'float64')\n # Now we retrieve data for each field\n ig = count = 0\n for level in range(self.max_level, -1, -1):\n for grid in self.select_grids(level):\n nidx = len(pstore[ig])\n if nidx > 0:\n for p in pfields:\n result[p][count:count+nidx] = grid[p][pstore[ig]]\n count += nidx\n ig += 1\n if count >= total: break\n if count >= total: break\n # Crop data if retrieved more than max_num\n if count > max_num:\n for p in pfields:\n result[p] = result[p][0:max_num]\n return result\n\nclass EnzoHierarchyInMemory(EnzoHierarchy):\n\n grid = EnzoGridInMemory\n _enzo = None\n\n @property\n def enzo(self):\n if self._enzo is None:\n import enzo\n self._enzo = enzo\n return self._enzo\n\n def __init__(self, ds, dataset_type = None):\n self.dataset_type = dataset_type\n self.float_type = 'float64'\n self.dataset = weakref.proxy(ds) # for _obtain_enzo\n self.float_type = self.enzo.hierarchy_information[\"GridLeftEdge\"].dtype\n self.directory = os.getcwd()\n GridIndex.__init__(self, ds, dataset_type)\n\n def _initialize_data_storage(self):\n pass\n\n def _count_grids(self):\n self.num_grids = self.enzo.hierarchy_information[\"GridDimensions\"].shape[0]\n\n def _parse_index(self):\n self._copy_index_structure()\n mylog.debug(\"Copying reverse tree\")\n reverse_tree = self.enzo.hierarchy_information[\"GridParentIDs\"].ravel().tolist()\n # Initial setup:\n mylog.debug(\"Reconstructing parent-child relationships\")\n grids = []\n # We enumerate, so it's 0-indexed id and 1-indexed pid\n self.filenames = [\"-1\"] * self.num_grids\n for id,pid in enumerate(reverse_tree):\n grids.append(self.grid(id+1, self))\n grids[-1].Level = self.grid_levels[id, 0]\n if pid > 0:\n grids[-1]._parent_id = pid\n grids[pid-1]._children_ids.append(grids[-1].id)\n self.max_level = self.grid_levels.max()\n mylog.debug(\"Preparing grids\")\n self.grids = np.empty(len(grids), dtype='object')\n for i, grid in enumerate(grids):\n if (i%1e4) == 0: mylog.debug(\"Prepared % 7i / % 7i grids\", i, self.num_grids)\n grid.filename = \"Inline_processor_%07i\" % (self.grid_procs[i,0])\n grid._prepare_grid()\n grid.proc_num = self.grid_procs[i,0]\n self.grids[i] = grid\n mylog.debug(\"Prepared\")\n\n def _initialize_grid_arrays(self):\n EnzoHierarchy._initialize_grid_arrays(self)\n self.grid_procs = np.zeros((self.num_grids,1),'int32')\n\n def _copy_index_structure(self):\n # Dimensions are important!\n self.grid_dimensions[:] = self.enzo.hierarchy_information[\"GridEndIndices\"][:]\n self.grid_dimensions -= self.enzo.hierarchy_information[\"GridStartIndices\"][:]\n self.grid_dimensions += 1\n self.grid_left_edge[:] = self.enzo.hierarchy_information[\"GridLeftEdge\"][:]\n self.grid_right_edge[:] = self.enzo.hierarchy_information[\"GridRightEdge\"][:]\n self.grid_levels[:] = self.enzo.hierarchy_information[\"GridLevels\"][:]\n self.grid_procs = self.enzo.hierarchy_information[\"GridProcs\"].copy()\n self.grid_particle_count[:] = self.enzo.hierarchy_information[\"GridNumberOfParticles\"][:]\n\n def save_data(self, *args, **kwargs):\n pass\n\n _cached_field_list = None\n _cached_derived_field_list = None\n\n def _generate_random_grids(self):\n my_rank = self.comm.rank\n my_grids = self.grids[self.grid_procs.ravel() == my_rank]\n if len(my_grids) > 40:\n starter = np.random.randint(0, 20)\n random_sample = np.mgrid[starter:len(my_grids)-1:20j].astype(\"int32\")\n mylog.debug(\"Checking grids: %s\", random_sample.tolist())\n else:\n random_sample = np.mgrid[0:max(len(my_grids)-1,1)].astype(\"int32\")\n return my_grids[(random_sample,)]\n\n def _chunk_io(self, dobj, cache = True, local_only = False):\n gfiles = defaultdict(list)\n gobjs = getattr(dobj._current_chunk, \"objs\", dobj._chunk_info)\n for g in gobjs:\n gfiles[g.filename].append(g)\n for fn in sorted(gfiles):\n if local_only:\n gobjs = [g for g in gfiles[fn] if g.proc_num == self.comm.rank]\n gfiles[fn] = gobjs\n gs = gfiles[fn]\n count = self._count_selection(dobj, gs)\n yield YTDataChunk(dobj, \"io\", gs, count, cache = cache)\n\n\nclass EnzoHierarchy1D(EnzoHierarchy):\n\n def _fill_arrays(self, ei, si, LE, RE, npart, nap):\n self.grid_dimensions[:,:1] = ei\n self.grid_dimensions[:,:1] -= np.array(si, self.float_type)\n self.grid_dimensions += 1\n self.grid_left_edge[:,:1] = LE\n self.grid_right_edge[:,:1] = RE\n self.grid_particle_count.flat[:] = npart\n self.grid_left_edge[:,1:] = 0.0\n self.grid_right_edge[:,1:] = 1.0\n self.grid_dimensions[:,1:] = 1\n if nap is not None:\n raise NotImplementedError\n\nclass EnzoHierarchy2D(EnzoHierarchy):\n\n def _fill_arrays(self, ei, si, LE, RE, npart, nap):\n self.grid_dimensions[:,:2] = ei\n self.grid_dimensions[:,:2] -= np.array(si, self.float_type)\n self.grid_dimensions += 1\n self.grid_left_edge[:,:2] = LE\n self.grid_right_edge[:,:2] = RE\n self.grid_particle_count.flat[:] = npart\n self.grid_left_edge[:,2] = 0.0\n self.grid_right_edge[:,2] = 1.0\n self.grid_dimensions[:,2] = 1\n if nap is not None:\n raise NotImplementedError\n\nclass EnzoDataset(Dataset):\n \"\"\"\n Enzo-specific output, set at a fixed time.\n \"\"\"\n _index_class = EnzoHierarchy\n _field_info_class = EnzoFieldInfo\n\n def __init__(self, filename, dataset_type=None,\n file_style = None,\n parameter_override = None,\n conversion_override = None,\n storage_filename = None,\n units_override=None):\n \"\"\"\n This class is a stripped down class that simply reads and parses\n *filename* without looking at the index. *dataset_type* gets passed\n to the index to pre-determine the style of data-output. However,\n it is not strictly necessary. Optionally you may specify a\n *parameter_override* dictionary that will override anything in the\n paarmeter file and a *conversion_override* dictionary that consists\n of {fieldname : conversion_to_cgs} that will override the #DataCGS.\n \"\"\"\n self.fluid_types += (\"enzo\",)\n if filename.endswith(\".hierarchy\"): filename = filename[:-10]\n if parameter_override is None: parameter_override = {}\n self._parameter_override = parameter_override\n if conversion_override is None: conversion_override = {}\n self._conversion_override = conversion_override\n self.storage_filename = storage_filename\n Dataset.__init__(self, filename, dataset_type, file_style=file_style,\n units_override=units_override)\n\n def _setup_1d(self):\n self._index_class = EnzoHierarchy1D\n self.domain_left_edge = \\\n np.concatenate([[self.domain_left_edge], [0.0, 0.0]])\n self.domain_right_edge = \\\n np.concatenate([[self.domain_right_edge], [1.0, 1.0]])\n\n def _setup_2d(self):\n self._index_class = EnzoHierarchy2D\n self.domain_left_edge = \\\n np.concatenate([self.domain_left_edge, [0.0]])\n self.domain_right_edge = \\\n np.concatenate([self.domain_right_edge, [1.0]])\n\n def get_parameter(self,parameter,type=None):\n \"\"\"\n Gets a parameter not in the parameterDict.\n \"\"\"\n if parameter in self.parameters:\n return self.parameters[parameter]\n for line in open(self.parameter_filename):\n if line.find(\"#\") >= 1: # Keep the commented lines\n line=line[:line.find(\"#\")]\n line=line.strip().rstrip()\n if len(line) < 2:\n continue\n try:\n param, vals = map(string.strip,map(string.rstrip,\n line.split(\"=\")))\n except ValueError:\n mylog.error(\"ValueError: '%s'\", line)\n if parameter == param:\n if type is None:\n t = vals.split()\n else:\n t = map(type, vals.split())\n if len(t) == 1:\n self.parameters[param] = t[0]\n else:\n self.parameters[param] = t\n if param.endswith(\"Units\") and not param.startswith(\"Temperature\"):\n dataType = param[:-5]\n self.conversion_factors[dataType] = self.parameters[param]\n return self.parameters[parameter]\n\n return \"\"\n\n def _parse_parameter_file(self):\n \"\"\"\n Parses the parameter file and establishes the various\n dictionaries.\n \"\"\"\n # Let's read the file\n with open(self.parameter_filename, \"r\") as f:\n line = f.readline().strip() \n f.seek(0)\n if line == \"Internal:\":\n self._parse_enzo3_parameter_file(f)\n else:\n self._parse_enzo2_parameter_file(f)\n\n def _parse_enzo3_parameter_file(self, f):\n self.parameters = p = libconfig(f)\n sim = p[\"SimulationControl\"]\n internal = p[\"Internal\"]\n phys = p[\"Physics\"]\n self.refine_by = sim[\"AMR\"][\"RefineBy\"]\n self.periodicity = tuple(a == 3 for a in\n sim[\"Domain\"][\"LeftFaceBoundaryCondition\"])\n self.dimensionality = sim[\"Domain\"][\"TopGridRank\"]\n self.domain_dimensions = np.array(sim[\"Domain\"][\"TopGridDimensions\"],\n dtype=\"int64\")\n self.domain_left_edge = np.array(sim[\"Domain\"][\"DomainLeftEdge\"],\n dtype=\"float64\")\n self.domain_right_edge = np.array(sim[\"Domain\"][\"DomainRightEdge\"],\n dtype=\"float64\")\n self.gamma = phys[\"Hydro\"][\"Gamma\"]\n self.unique_identifier = internal[\"Provenance\"][\"CurrentTimeIdentifier\"]\n self.current_time = internal[\"InitialTime\"]\n self.cosmological_simulation = phys[\"Cosmology\"][\"ComovingCoordinates\"]\n if self.cosmological_simulation == 1:\n cosmo = phys[\"Cosmology\"]\n self.current_redshift = internal[\"CosmologyCurrentRedshift\"]\n self.omega_lambda = cosmo[\"OmegaLambdaNow\"]\n self.omega_matter = cosmo[\"OmegaMatterNow\"]\n self.hubble_constant = cosmo[\"HubbleConstantNow\"]\n else:\n self.current_redshift = self.omega_lambda = self.omega_matter = \\\n self.hubble_constant = self.cosmological_simulation = 0.0\n self.particle_types = [\"DarkMatter\"] + \\\n phys[\"ActiveParticles\"][\"ActiveParticlesEnabled\"]\n self.particle_types = tuple(self.particle_types)\n self.particle_types_raw = self.particle_types\n if self.dimensionality == 1:\n self._setup_1d()\n elif self.dimensionality == 2:\n self._setup_2d()\n\n def _parse_enzo2_parameter_file(self, f):\n for line in (l.strip() for l in f):\n if len(line) < 2: continue\n param, vals = (i.strip() for i in line.split(\"=\",1))\n # First we try to decipher what type of value it is.\n vals = vals.split()\n # Special case approaching.\n if \"(do\" in vals: vals = vals[:1]\n if len(vals) == 0:\n pcast = str # Assume NULL output\n else:\n v = vals[0]\n # Figure out if it's castable to floating point:\n try:\n float(v)\n except ValueError:\n pcast = str\n else:\n if any(\".\" in v or \"e+\" in v or \"e-\" in v for v in vals):\n pcast = float\n elif v == \"inf\":\n pcast = str\n else:\n pcast = int\n # Now we figure out what to do with it.\n if len(vals) == 0:\n vals = \"\"\n elif len(vals) == 1:\n vals = pcast(vals[0])\n else:\n vals = np.array([pcast(i) for i in vals if i != \"-99999\"])\n if param.startswith(\"Append\"):\n if param not in self.parameters:\n self.parameters[param] = []\n self.parameters[param].append(vals)\n else:\n self.parameters[param] = vals\n self.refine_by = self.parameters[\"RefineBy\"]\n self.periodicity = ensure_tuple(\n self.parameters[\"LeftFaceBoundaryCondition\"] == 3)\n self.dimensionality = self.parameters[\"TopGridRank\"]\n if \"MetaDataDatasetUUID\" in self.parameters:\n self.unique_identifier = self.parameters[\"MetaDataDatasetUUID\"]\n elif \"CurrentTimeIdentifier\" in self.parameters:\n self.unique_identifier = self.parameters[\"CurrentTimeIdentifier\"]\n else:\n self.unique_identifier = \\\n int(os.stat(self.parameter_filename)[stat.ST_CTIME])\n if self.dimensionality > 1:\n self.domain_dimensions = self.parameters[\"TopGridDimensions\"]\n if len(self.domain_dimensions) < 3:\n tmp = self.domain_dimensions.tolist()\n tmp.append(1)\n self.domain_dimensions = np.array(tmp)\n self.periodicity += (False,)\n self.domain_left_edge = np.array(self.parameters[\"DomainLeftEdge\"],\n \"float64\").copy()\n self.domain_right_edge = np.array(self.parameters[\"DomainRightEdge\"],\n \"float64\").copy()\n else:\n self.domain_left_edge = np.array(self.parameters[\"DomainLeftEdge\"],\n \"float64\")\n self.domain_right_edge = np.array(self.parameters[\"DomainRightEdge\"],\n \"float64\")\n self.domain_dimensions = np.array([self.parameters[\"TopGridDimensions\"],1,1])\n self.periodicity += (False, False)\n\n self.gamma = self.parameters[\"Gamma\"]\n # To be enabled when we can break old pickles:\n #if \"MetaDataSimulationUUID\" in self.parameters:\n # self.unique_identifier = self.parameters[\"MetaDataSimulationUUID\"]\n self.unique_identifier = self.parameters.get(\"MetaDataDatasetUUID\",\n self.parameters.get(\"CurrentTimeIdentifier\", None))\n if self.parameters[\"ComovingCoordinates\"]:\n self.cosmological_simulation = 1\n self.current_redshift = self.parameters[\"CosmologyCurrentRedshift\"]\n self.omega_lambda = self.parameters[\"CosmologyOmegaLambdaNow\"]\n self.omega_matter = self.parameters[\"CosmologyOmegaMatterNow\"]\n self.hubble_constant = self.parameters[\"CosmologyHubbleConstantNow\"]\n else:\n self.current_redshift = self.omega_lambda = self.omega_matter = \\\n self.hubble_constant = self.cosmological_simulation = 0.0\n self.particle_types = []\n self.current_time = self.parameters[\"InitialTime\"]\n if self.parameters[\"NumberOfParticles\"] > 0 and \\\n \"AppendActiveParticleType\" in self.parameters.keys():\n # If this is the case, then we know we should have a DarkMatter\n # particle type, and we don't need the \"io\" type.\n self.parameters[\"AppendActiveParticleType\"].append(\"DarkMatter\")\n else:\n # We do not have an \"io\" type for Enzo particles if the\n # ActiveParticle machinery is on, as we simply will ignore any of\n # the non-DarkMatter particles in that case. However, for older\n # datasets, we call this particle type \"io\".\n self.particle_types = [\"io\"]\n for ptype in self.parameters.get(\"AppendActiveParticleType\", []):\n self.particle_types.append(ptype)\n self.particle_types = tuple(self.particle_types)\n self.particle_types_raw = self.particle_types\n\n if self.dimensionality == 1:\n self._setup_1d()\n elif self.dimensionality == 2:\n self._setup_2d()\n\n def _set_code_unit_attributes(self):\n if self.cosmological_simulation:\n k = self.cosmology_get_units()\n # Now some CGS values\n box_size = self.parameters.get(\"CosmologyComovingBoxSize\", None)\n if box_size is None:\n box_size = self.parameters[\"Physics\"][\"Cosmology\"]\\\n [\"CosmologyComovingBoxSize\"]\n self.length_unit = self.quan(box_size, \"Mpccm/h\")\n self.mass_unit = \\\n self.quan(k['urho'], 'g/cm**3') * (self.length_unit.in_cgs())**3\n self.time_unit = self.quan(k['utim'], 's')\n self.velocity_unit = self.quan(k['uvel'], 'cm/s')\n else:\n if \"LengthUnits\" in self.parameters:\n length_unit = self.parameters[\"LengthUnits\"]\n mass_unit = self.parameters[\"DensityUnits\"] * length_unit**3\n time_unit = self.parameters[\"TimeUnits\"]\n elif \"SimulationControl\" in self.parameters:\n units = self.parameters[\"SimulationControl\"][\"Units\"]\n length_unit = units[\"Length\"]\n mass_unit = units[\"Density\"] * length_unit**3\n time_unit = units[\"Time\"]\n else:\n mylog.warning(\"Setting 1.0 in code units to be 1.0 cm\")\n mylog.warning(\"Setting 1.0 in code units to be 1.0 s\")\n length_unit = mass_unit = time_unit = 1.0\n\n self.length_unit = self.quan(length_unit, \"cm\")\n self.mass_unit = self.quan(mass_unit, \"g\")\n self.time_unit = self.quan(time_unit, \"s\")\n self.velocity_unit = self.length_unit / self.time_unit\n\n magnetic_unit = np.sqrt(4*np.pi * self.mass_unit /\n (self.time_unit**2 * self.length_unit))\n magnetic_unit = np.float64(magnetic_unit.in_cgs())\n self.magnetic_unit = self.quan(magnetic_unit, \"gauss\")\n\n def cosmology_get_units(self):\n \"\"\"\n Return an Enzo-fortran style dictionary of units to feed into custom\n routines. This is typically only necessary if you are interacting\n with fortran code.\n \"\"\"\n k = {}\n k[\"utim\"] = 2.52e17/np.sqrt(self.omega_matter)\\\n / self.hubble_constant \\\n / (1+self.parameters[\"CosmologyInitialRedshift\"])**1.5\n k[\"urho\"] = rho_crit_g_cm3_h2 * self.omega_matter \\\n * self.hubble_constant**2 \\\n * (1.0 + self.current_redshift)**3\n k[\"uxyz\"] = cm_per_mpc * \\\n self.parameters[\"CosmologyComovingBoxSize\"] / \\\n self.hubble_constant / \\\n (1.0 + self.current_redshift)\n k[\"uaye\"] = 1.0/(1.0 + self.parameters[\"CosmologyInitialRedshift\"])\n k[\"uvel\"] = 1.225e7*self.parameters[\"CosmologyComovingBoxSize\"] \\\n *np.sqrt(self.omega_matter) \\\n *np.sqrt(1+ self.parameters[\"CosmologyInitialRedshift\"])\n k[\"utem\"] = 1.88e6 * (self.parameters[\"CosmologyComovingBoxSize\"]**2) \\\n * self.omega_matter \\\n * (1.0 + self.parameters[\"CosmologyInitialRedshift\"])\n k[\"aye\"] = (1.0 + self.parameters[\"CosmologyInitialRedshift\"]) / \\\n (1.0 + self.current_redshift)\n return k\n\n @classmethod\n def _is_valid(cls, *args, **kwargs):\n if (\"%s\" % (args[0])).endswith(\".hierarchy\"):\n return True\n return os.path.exists(\"%s.hierarchy\" % args[0])\n\nclass EnzoDatasetInMemory(EnzoDataset):\n _index_class = EnzoHierarchyInMemory\n _dataset_type = 'enzo_inline'\n\n def __new__(cls, *args, **kwargs):\n obj = object.__new__(cls)\n obj.__init__(*args, **kwargs)\n return obj\n\n def __init__(self, parameter_override=None, conversion_override=None):\n self.fluid_types += (\"enzo\",)\n if parameter_override is None: parameter_override = {}\n self._parameter_override = parameter_override\n if conversion_override is None: conversion_override = {}\n self._conversion_override = conversion_override\n\n Dataset.__init__(self, \"InMemoryParameterFile\", self._dataset_type)\n\n def _parse_parameter_file(self):\n enzo = self._obtain_enzo()\n self.basename = \"cycle%08i\" % (\n enzo.yt_parameter_file[\"NumberOfPythonCalls\"])\n self.parameters['CurrentTimeIdentifier'] = time.time()\n self.parameters.update(enzo.yt_parameter_file)\n self.conversion_factors.update(enzo.conversion_factors)\n for i in self.parameters:\n if isinstance(self.parameters[i], tuple):\n self.parameters[i] = np.array(self.parameters[i])\n if i.endswith(\"Units\") and not i.startswith(\"Temperature\"):\n dataType = i[:-5]\n self.conversion_factors[dataType] = self.parameters[i]\n self.domain_left_edge = self.parameters[\"DomainLeftEdge\"].copy()\n self.domain_right_edge = self.parameters[\"DomainRightEdge\"].copy()\n for i in self.conversion_factors:\n if isinstance(self.conversion_factors[i], tuple):\n self.conversion_factors[i] = np.array(self.conversion_factors[i])\n for p, v in self._parameter_override.items():\n self.parameters[p] = v\n for p, v in self._conversion_override.items():\n self.conversion_factors[p] = v\n self.refine_by = self.parameters[\"RefineBy\"]\n self.periodicity = ensure_tuple(self.parameters[\"LeftFaceBoundaryCondition\"] == 3)\n self.dimensionality = self.parameters[\"TopGridRank\"]\n self.domain_dimensions = self.parameters[\"TopGridDimensions\"]\n self.current_time = self.parameters[\"InitialTime\"]\n if \"CurrentTimeIdentifier\" in self.parameters:\n self.unique_identifier = self.parameters[\"CurrentTimeIdentifier\"]\n if self.parameters[\"ComovingCoordinates\"]:\n self.cosmological_simulation = 1\n self.current_redshift = self.parameters[\"CosmologyCurrentRedshift\"]\n self.omega_lambda = self.parameters[\"CosmologyOmegaLambdaNow\"]\n self.omega_matter = self.parameters[\"CosmologyOmegaMatterNow\"]\n self.hubble_constant = self.parameters[\"CosmologyHubbleConstantNow\"]\n else:\n self.current_redshift = self.omega_lambda = self.omega_matter = \\\n self.hubble_constant = self.cosmological_simulation = 0.0\n\n def _obtain_enzo(self):\n import enzo; return enzo\n\n @classmethod\n def _is_valid(cls, *args, **kwargs):\n return False\n\n# These next two functions are taken from\n# http://www.reddit.com/r/Python/comments/6hj75/reverse_file_iterator/c03vms4\n# Credit goes to \"Brian\" on Reddit\n\ndef rblocks(f, blocksize=4096):\n \"\"\"Read file as series of blocks from end of file to start.\n\n The data itself is in normal order, only the order of the blocks is reversed.\n ie. \"hello world\" -> [\"ld\",\"wor\", \"lo \", \"hel\"]\n Note that the file must be opened in binary mode.\n \"\"\"\n if 'b' not in f.mode.lower():\n raise Exception(\"File must be opened using binary mode.\")\n size = os.stat(f.name).st_size\n fullblocks, lastblock = divmod(size, blocksize)\n\n # The first(end of file) block will be short, since this leaves\n # the rest aligned on a blocksize boundary. This may be more\n # efficient than having the last (first in file) block be short\n f.seek(-lastblock,2)\n yield f.read(lastblock).decode('ascii')\n\n for i in range(fullblocks-1,-1, -1):\n f.seek(i * blocksize)\n yield f.read(blocksize).decode('ascii')\n\ndef rlines(f, keepends=False):\n \"\"\"Iterate through the lines of a file in reverse order.\n\n If keepends is true, line endings are kept as part of the line.\n \"\"\"\n buf = ''\n for block in rblocks(f):\n buf = block + buf\n lines = buf.splitlines(keepends)\n # Return all lines except the first (since may be partial)\n if lines:\n lines.reverse()\n buf = lines.pop() # Last line becomes end of new first line.\n for line in lines:\n yield line\n yield buf # First line.\n\n"
] | [
[
"numpy.prod",
"numpy.empty",
"numpy.dtype",
"numpy.fromfile"
],
[
"numpy.distutils.misc_util.Configuration"
],
[
"numpy.concatenate",
"numpy.array",
"numpy.ones_like",
"numpy.union1d",
"numpy.testing.assert_array_equal",
"numpy.copy",
"numpy.float64",
"numpy.arange",
"numpy.power",
"numpy.sqrt",
"numpy.intersect1d",
"numpy.random.random",
"numpy.testing.assert_raises"
],
[
"numpy.concatenate",
"numpy.array",
"numpy.empty",
"numpy.zeros",
"numpy.rint",
"numpy.multiply",
"numpy.any",
"numpy.where",
"numpy.random.randint",
"numpy.sqrt"
]
] |
nbingo/sMOOth | [
"aacdc5d24b931e534e984681923ec74f1103ca2f"
] | [
"src/configs/adult/adult_mlp_weighted.py"
] | [
"\"\"\"\nAn example config file to train a ImageNet classifier with detectron2.\nModel and dataloader both come from torchvision.\nThis shows how to use detectron2 as a general engine for any new models and tasks.\n\nTo run, use the following command:\n\npython tools/lazyconfig_train_net.py --config-file configs/Misc/torchvision_imagenet_R_50.py \\\n --num-gpus 8 dataloader.train.dataset.root=/path/to/imagenet/\n\n\"\"\"\n\nimport yaml\nimport torch\nfrom omegaconf import OmegaConf\nfrom fvcore.common.param_scheduler import CosineParamScheduler\n\nfrom detectron2.solver import WarmupParamScheduler\nfrom detectron2.solver.build import get_default_optimizer_params\nfrom detectron2.config import LazyConfig, LazyCall as L\nfrom detectron2.evaluation import DatasetEvaluators\n\nfrom src.configs.common.utils import build_data_loader\nfrom src.models.adult_mlp import IncomeClassifier\nfrom src.loaders.adult_loader import FeatDataset\nfrom src.metrics.evaluators import ClassificationAcc, BinaryEqualizedOddsViolation\nfrom src.metrics.losses import cross_entropy_loss, equalized_odds_violation, MultiObjectiveLoss\nfrom src.harnesses.harnesses import MultiProcessHarness, SimpleHarness\n\ndataloader = OmegaConf.create()\ndataloader.train = L(build_data_loader)(\n dataset=L(FeatDataset)(\n subset='train',\n income_const=yaml.load(open('/lfs/local/0/nomir/sMOOth/data/Adult/income.yml'), Loader=yaml.FullLoader)\n ),\n batch_size=256,\n num_workers=4,\n training=True,\n)\n\ndataloader.test = L(build_data_loader)(\n dataset=L(FeatDataset)(\n subset='val',\n income_const=yaml.load(open('/lfs/local/0/nomir/sMOOth/data/Adult/income.yml'), Loader=yaml.FullLoader)\n ),\n batch_size=256,\n num_workers=4,\n training=False,\n)\n\n# Can also be list of DatasetEvaluators\ndataloader.evaluator = L(DatasetEvaluators)(evaluators=(ClassificationAcc(), BinaryEqualizedOddsViolation()))\n\ntrain = LazyConfig.load(\"/lfs/local/0/nomir/sMOOth/src/configs/common/train.py\").train\ntrain.init_checkpoint = None\n# max_iter = number epochs * (train dataset size / batch size)\ntrain.max_iter = 50 * 30162 // 256\ntrain.eval_period = 30162 // 256\ntrain.loss_fn = L(MultiObjectiveLoss)(losses=[cross_entropy_loss, equalized_odds_violation])\ntrain.loss_tradeoff = torch.Tensor([0.5, 0.5])\n# Arguments for multiprocess training\ntrain.harness = SimpleHarness\ntrain.num_workers = 1\ntrain.gpus = [0] # TODO: Eventually want this to be a commandline arg\ntrain.process_over_key = 'model.loss_fn'\ntrain.process_over_vals = [cross_entropy_loss]\n\nmodel = L(IncomeClassifier)(\n in_dim=105,\n hidden_dim=105,\n num_hidden_blocks=2,\n drop_prob=0.2,\n out_dim=2,\n loss_fn=train.loss_fn,\n device=train.device,\n)\n\noptimizer = L(torch.optim.Adam)(\n params=L(get_default_optimizer_params)(),\n lr=1e-3,\n weight_decay=1e-4,\n)\n\nlr_multiplier = L(WarmupParamScheduler)(\n scheduler=L(CosineParamScheduler)(\n start_value=0.1,\n end_value=1e-4,\n ),\n warmup_length=1 / 100,\n warmup_factor=0.1,\n)\n"
] | [
[
"torch.Tensor"
]
] |
FujitsuResearch/automatic_pruning | [
"b3bb525b736ca3e465cb6fb87f134748424a0fe5"
] | [
"examples/resnet34_imagenet/resnet34.py"
] | [
"# resnet34.py COPYRIGHT Fujitsu Limited 2022\n\nimport torch.nn as nn\nimport torch.nn.functional as F\n\ndef zero_padding(x1, x2):\n num_ch1 = x1.size()[1]\n num_ch2 = x2.size()[1]\n ch_diff = num_ch1 - num_ch2\n # path1 < path2 : zero padding to path1 tensor\n if num_ch1 < num_ch2:\n ch_diff = -1 * ch_diff\n if ch_diff%2 ==0:\n x1 = F.pad(x1[:, :, :, :], (0, 0, 0, 0, ch_diff//2, ch_diff//2), \"constant\", 0)\n else:\n x1 = F.pad(x1[:, :, :, :], (0, 0, 0, 0, ch_diff//2, (ch_diff//2)+1), \"constant\", 0)\n # path1 > path2 : zero padding to path2 tensor\n elif num_ch1 > num_ch2:\n if ch_diff%2 ==0:\n x2 = F.pad(x2[:, :, :, :], (0, 0, 0, 0, ch_diff//2, ch_diff//2), \"constant\", 0)\n else:\n x2 = F.pad(x2[:, :, :, :], (0, 0, 0, 0, ch_diff//2, (ch_diff//2)+1), \"constant\", 0)\n return x1, x2\n\n\ndef conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):\n \"\"\"3x3 convolution with padding\"\"\"\n return nn.Conv2d(\n in_planes,\n out_planes,\n kernel_size=3,\n stride=stride,\n padding=dilation,\n groups=groups,\n bias=False,\n dilation=dilation,\n )\n\n\ndef conv1x1(in_planes, out_planes, stride=1):\n \"\"\"1x1 convolution\"\"\"\n return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)\n\n\nclass BasicBlock(nn.Module):\n expansion = 1\n\n def __init__(\n self,\n inplanes,\n planes,\n stride=1,\n downsample=None,\n groups=1,\n base_width=64,\n dilation=1,\n norm_layer=None,\n n_in_channels=None,\n n_channels1=None,\n n_channels2=None,\n ):\n super(BasicBlock, self).__init__()\n if norm_layer is None:\n norm_layer = nn.BatchNorm2d\n if groups != 1 or base_width != 64:\n raise ValueError(\"BasicBlock only supports groups=1 and base_width=64\")\n if dilation > 1:\n raise NotImplementedError(\"Dilation > 1 not supported in BasicBlock\")\n\n # Both self.conv1 and self.downsample layers downsample the input when stride != 1\n self.conv1 = conv3x3(n_in_channels, n_channels1, stride)\n self.bn1 = norm_layer(n_channels1)\n self.relu = nn.ReLU(inplace=True)\n self.conv2 = conv3x3(n_channels1, n_channels2)\n self.bn2 = norm_layer(n_channels2)\n self.downsample = downsample #if dawnsample else downsample(n_in_channels, n_channels3)\n self.stride = stride\n\n\n def forward(self, x):\n identity = x\n\n out = self.conv1(x)\n out = self.bn1(out)\n out = self.relu(out)\n\n out = self.conv2(out)\n out = self.bn2(out)\n\n if self.downsample is not None:\n identity = self.downsample(x)\n\n out, identity = zero_padding(out, identity) # zero padding\n out += identity\n out = self.relu(out)\n\n return out\n\n\nclass ResNet34(nn.Module):\n def __init__(\n self,\n block=BasicBlock,\n layers=[3, 4, 6, 3],\n num_classes=1000,\n zero_init_residual=False,\n groups=1,\n width_per_group=64,\n replace_stride_with_dilation=None,\n norm_layer=None,\n ch_conv1=64,\n\n ch_l10_1=64,\n ch_l10_2=64,\n ch_l11_1=64,\n ch_l11_2=64,\n ch_l12_1=64,\n ch_l12_2=64,\n\n ch_l20_1=128,\n ch_l20_2=128,\n ch_l20_ds=128,\n ch_l21_1=128,\n ch_l21_2=128,\n ch_l22_1=128,\n ch_l22_2=128,\n ch_l23_1=128,\n ch_l23_2=128,\n\n ch_l30_1=256,\n ch_l30_2=256,\n ch_l30_ds=256,\n ch_l31_1=256,\n ch_l31_2=256,\n ch_l32_1=256,\n ch_l32_2=256,\n ch_l33_1=256,\n ch_l33_2=256,\n ch_l34_1=256,\n ch_l34_2=256,\n ch_l35_1=256,\n ch_l35_2=256,\n\n ch_l40_1=512,\n ch_l40_2=512,\n ch_l40_ds=512,\n ch_l41_1=512,\n ch_l41_2=512,\n ch_l42_1=512,\n ch_l42_2=512,\n ):\n super(ResNet34, self).__init__()\n if norm_layer is None:\n norm_layer = nn.BatchNorm2d\n self._norm_layer = norm_layer\n\n self.inplanes = 64\n self.dilation = 1\n if replace_stride_with_dilation is None:\n # each element in the tuple indicates if we should replace\n # the 2x2 stride with a dilated convolution instead\n replace_stride_with_dilation = [False, False, False]\n if len(replace_stride_with_dilation) != 3:\n raise ValueError(\n \"replace_stride_with_dilation should be None \"\n \"or a 3-element tuple, got {}\".format(replace_stride_with_dilation)\n )\n self.groups = groups\n self.base_width = width_per_group\n self.conv1 = nn.Conv2d(3, ch_conv1, kernel_size=7, stride=2, padding=3, bias=False)\n self.bn1 = norm_layer(ch_conv1)\n self.relu = nn.ReLU(inplace=True)\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n\n in_ch_l11 = max(ch_conv1, ch_l10_2)\n in_ch_l12 = max(in_ch_l11, ch_l11_2)\n self.layer1 = self._make_layer_3(block=block, planes=64, blocks=layers[0],\n n_in_channels0=ch_conv1,\n n_channels00=ch_l10_1,\n n_channels01=ch_l10_2,\n n_channels_ds=None,\n n_in_channels1=in_ch_l11,\n n_channels10=ch_l11_1,\n n_channels11=ch_l11_2,\n n_in_channels2=in_ch_l12,\n n_channels20=ch_l12_1,\n n_channels21=ch_l12_2,\n )\n\n in_ch_l20 = max(in_ch_l12, ch_l12_2)\n in_ch_l21 = max(ch_l20_ds, ch_l20_2)\n in_ch_l22 = max(in_ch_l21, ch_l21_2)\n in_ch_l23 = max(in_ch_l22, ch_l22_2) \n self.layer2 = self._make_layer_4(block, 128, layers[1], stride=2,\n dilate=replace_stride_with_dilation[0],\n n_in_channels0=in_ch_l20,\n n_channels00=ch_l20_1,\n n_channels01=ch_l20_2,\n n_channels_ds=ch_l20_ds,\n n_in_channels1=in_ch_l21,\n n_channels10=ch_l21_1,\n n_channels11=ch_l21_2,\n n_in_channels2=in_ch_l22,\n n_channels20=ch_l22_1,\n n_channels21=ch_l22_2,\n n_in_channels3=in_ch_l23,\n n_channels30=ch_l23_1,\n n_channels31=ch_l23_2,\n )\n\n in_ch_l30 = max(in_ch_l23, ch_l23_2)\n in_ch_l31 = max(ch_l30_ds, ch_l30_2)\n in_ch_l32 = max(in_ch_l31, ch_l31_2)\n in_ch_l33 = max(in_ch_l32, ch_l32_2)\n in_ch_l34 = max(in_ch_l33, ch_l33_2)\n in_ch_l35 = max(in_ch_l34, ch_l34_2)\n self.layer3 = self._make_layer_6(block, 256, layers[2], stride=2,\n dilate=replace_stride_with_dilation[1],\n n_in_channels0=in_ch_l30,\n n_channels00=ch_l30_1,\n n_channels01=ch_l30_2,\n n_channels_ds=ch_l30_ds,\n n_in_channels1=in_ch_l31,\n n_channels10=ch_l31_1,\n n_channels11=ch_l31_2,\n n_in_channels2=in_ch_l32,\n n_channels20=ch_l32_1,\n n_channels21=ch_l32_2,\n n_in_channels3=in_ch_l33,\n n_channels30=ch_l33_1,\n n_channels31=ch_l33_2,\n n_in_channels4=in_ch_l34,\n n_channels40=ch_l34_1,\n n_channels41=ch_l34_2,\n n_in_channels5=in_ch_l35,\n n_channels50=ch_l35_1,\n n_channels51=ch_l35_2,\n )\n\n in_ch_l40 = max(in_ch_l35, ch_l35_2)\n in_ch_l41 = max(ch_l40_ds, ch_l40_2)\n in_ch_l42 = max(in_ch_l41, ch_l41_2)\n self.layer4 = self._make_layer_3(block, 512, layers[3], stride=2,\n dilate=replace_stride_with_dilation[2],\n n_in_channels0=in_ch_l40,\n n_channels00=ch_l40_1,\n n_channels01=ch_l40_2,\n n_channels_ds=ch_l40_ds,\n n_in_channels1=in_ch_l41,\n n_channels10=ch_l41_1,\n n_channels11=ch_l41_2,\n n_in_channels2=in_ch_l42,\n n_channels20=ch_l42_1,\n n_channels21=ch_l42_2,\n )\n\n in_ch_fc = max(in_ch_l42, ch_l42_2)\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n self.fc = nn.Linear(in_ch_fc, num_classes)\n\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n nn.init.kaiming_normal_(m.weight, mode=\"fan_out\", nonlinearity=\"relu\")\n elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):\n nn.init.constant_(m.weight, 1)\n nn.init.constant_(m.bias, 0)\n\n # Zero-initialize the last BN in each residual branch,\n # so that the residual branch starts with zeros, and each residual block behaves like an identity.\n # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677\n if zero_init_residual:\n for m in self.modules():\n if isinstance(m, Bottleneck):\n nn.init.constant_(m.bn3.weight, 0)\n elif isinstance(m, BasicBlock):\n nn.init.constant_(m.bn2.weight, 0)\n\n def _make_layer_3(self, block, planes, blocks, stride=1, dilate=False,\n n_in_channels0=None,\n n_channels00=None, n_channels01=None,\n n_channels_ds=None,\n n_in_channels1=None,\n n_channels10=None, n_channels11=None,\n n_in_channels2=None,\n n_channels20=None, n_channels21=None,\n ):\n\n norm_layer = self._norm_layer\n downsample = None\n previous_dilation = self.dilation\n if dilate:\n self.dilation *= stride\n stride = 1\n if stride != 1 or self.inplanes != planes * block.expansion:\n downsample = nn.Sequential( conv1x1(n_in_channels0, n_channels_ds, stride), norm_layer(n_channels_ds) )\n\n self.inplanes = planes * block.expansion\n layers = []\n\n # layer_0\n layers.append(\n block(\n self.inplanes,\n planes,\n stride,\n downsample,\n self.groups,\n self.base_width,\n previous_dilation,\n norm_layer,\n n_in_channels=n_in_channels0,\n n_channels1=n_channels00,\n n_channels2=n_channels01,\n )\n )\n # layer_1\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels1,\n n_channels1=n_channels10,\n n_channels2=n_channels11,\n )\n )\n # layer_2\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels2,\n n_channels1=n_channels20,\n n_channels2=n_channels21,\n )\n )\n return nn.Sequential(*layers)\n\n\n def _make_layer_4(self, block, planes, blocks, stride=1, dilate=False,\n n_in_channels0=None,\n n_channels00=None, n_channels01=None,\n n_channels_ds=None,\n n_in_channels1=None,\n n_channels10=None, n_channels11=None,\n n_in_channels2=None,\n n_channels20=None, n_channels21=None,\n n_in_channels3=None,\n n_channels30=None, n_channels31=None,\n ):\n\n norm_layer = self._norm_layer\n downsample = None\n previous_dilation = self.dilation\n if dilate:\n self.dilation *= stride\n stride = 1\n if stride != 1 or self.inplanes != planes * block.expansion:\n downsample = nn.Sequential( conv1x1(n_in_channels0, n_channels_ds, stride), norm_layer(n_channels_ds) )\n\n self.inplanes = planes * block.expansion\n layers = []\n\n # layer_0\n layers.append(\n block(\n self.inplanes,\n planes,\n stride,\n downsample,\n self.groups,\n self.base_width,\n previous_dilation,\n norm_layer,\n n_in_channels=n_in_channels0,\n n_channels1=n_channels00,\n n_channels2=n_channels01,\n )\n )\n # layer_1\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels1,\n n_channels1=n_channels10,\n n_channels2=n_channels11,\n )\n )\n # layer_2\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels2,\n n_channels1=n_channels20,\n n_channels2=n_channels21,\n )\n )\n # layer_3\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels3,\n n_channels1=n_channels30,\n n_channels2=n_channels31,\n )\n )\n return nn.Sequential(*layers)\n\n\n def _make_layer_6(self, block, planes, blocks, stride=1, dilate=False,\n n_in_channels0=None,\n n_channels00=None, n_channels01=None,\n n_channels_ds=None,\n n_in_channels1=None,\n n_channels10=None, n_channels11=None,\n n_in_channels2=None,\n n_channels20=None, n_channels21=None,\n n_in_channels3=None,\n n_channels30=None, n_channels31=None,\n n_in_channels4=None,\n n_channels40=None, n_channels41=None,\n n_in_channels5=None,\n n_channels50=None, n_channels51=None,\n ):\n\n norm_layer = self._norm_layer\n downsample = None\n previous_dilation = self.dilation\n if dilate:\n self.dilation *= stride\n stride = 1\n if stride != 1 or self.inplanes != planes * block.expansion:\n downsample = nn.Sequential( conv1x1(n_in_channels0, n_channels_ds, stride), norm_layer(n_channels_ds) )\n\n self.inplanes = planes * block.expansion\n layers = []\n\n # layer_0\n layers.append(\n block(\n self.inplanes,\n planes,\n stride,\n downsample,\n self.groups,\n self.base_width,\n previous_dilation,\n norm_layer,\n n_in_channels=n_in_channels0,\n n_channels1=n_channels00,\n n_channels2=n_channels01,\n )\n )\n # layer_1\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels1,\n n_channels1=n_channels10,\n n_channels2=n_channels11,\n )\n )\n # layer_2\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels2,\n n_channels1=n_channels20,\n n_channels2=n_channels21,\n )\n )\n # layer_3\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels3,\n n_channels1=n_channels30,\n n_channels2=n_channels31,\n )\n )\n # layer_4\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels4,\n n_channels1=n_channels40,\n n_channels2=n_channels41,\n )\n )\n # layer_5\n layers.append(\n block(\n self.inplanes,\n planes,\n groups=self.groups,\n base_width=self.base_width,\n dilation=self.dilation,\n norm_layer=norm_layer,\n n_in_channels=n_in_channels5,\n n_channels1=n_channels50,\n n_channels2=n_channels51,\n )\n )\n return nn.Sequential(*layers)\n\n def forward(self, x):\n x = self.conv1(x)\n x = self.bn1(x)\n x = self.relu(x)\n x = self.maxpool(x)\n\n x = self.layer1(x)\n x = self.layer2(x)\n x = self.layer3(x)\n x = self.layer4(x)\n\n x = self.avgpool(x)\n x = x.reshape(x.size(0), -1)\n x = self.fc(x)\n\n return x\n"
] | [
[
"torch.nn.Linear",
"torch.nn.MaxPool2d",
"torch.nn.Sequential",
"torch.nn.init.constant_",
"torch.nn.init.kaiming_normal_",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.functional.pad"
]
] |
hobinkwak/Stock-Movements-Classification | [
"dac2e90d9ef2294f5c4dc8f6605b9051c71b3f45"
] | [
"utils/dataload.py"
] | [
"from itertools import combinations\nimport pandas as pd\n\nfrom utils.utils import *\n\n\ndef load_etf():\n etf_data = pd.read_csv(\n \"data/etf_data.csv\", encoding=\"euc_kr\", parse_dates=[\"tdate\"]\n )\n etf_ohlcv = etf_data.set_index([\"tdate\", \"etf_code\", \"data_name\"])[\n \"value\"\n ].unstack()\n etf_close = etf_ohlcv[\"종가\"].unstack()\n return etf_close\n\ndef load_macro_data():\n macro_data = pd.read_csv('외부데이터/macro_final.csv', index_col='Item Name').iloc[1:, :]\n macro_data.index = pd.to_datetime(macro_data.index)\n macro_data = macro_data.fillna(method='ffill')\n macro_data = (macro_data.resample('m').last() / macro_data.resample('m').first())\n\n macro_data.columns = ['FOMC정책금리', '한국정책금리', '중국정책금리', '미국국채_1m', '미국국채_3m', '미국국채_6m', '미국국채_1y', '미국국채_5y',\n '미국국채_10y', '리보_달러_1m', '리보_달러_1y', '리보_달러_3m', '리보_달러_6m', '리보_달러_1w',\n 'DDR4 16G (2G*8) 2666 MHZ', 'NAND 16Gb 2Gx8 SLC', 'DDR4 16G (2G*8) eTT MHZ',\n 'DDR3 4Gb 512Mx8 1600/1866Mbps', 'DDR3 4Gb 512Mx8 eTT',\n 'NAND 8Gb 1Gx8 SLC', 'NAND 64Gb 8Gx8 MLC', 'WTI_1M', 'BRENT_1M', 'DUBAI_ASIA1M',\n '난방유_선물_NYMEX', '천연가스_선물_NYMEX', '가스오일_선물_IPE', '천연가스_선물_IPE', '금_선물', '은_선물', '알루미늄_선물',\n '전기동_선물', '납_선물', '니켈_선물', '주석_선물', '아연_선물', '10YR BEI', 'T10Y2Y', 'DFF',\n 'HY Ef Yield', 'Trade DI', 'VIX', 'USDKRW', 'Eco Policy Uncertainty']\n\n macro_data = macro_data[\n ['FOMC정책금리', '한국정책금리', '중국정책금리', '미국국채_1m', '미국국채_3m', '미국국채_6m', '미국국채_1y', '미국국채_5y', '미국국채_10y', '리보_달러_1m',\n '리보_달러_1y', '리보_달러_3m', '리보_달러_6m', '리보_달러_1w', 'DDR3 4Gb 512Mx8 eTT',\n 'NAND 8Gb 1Gx8 SLC', 'WTI_1M', 'BRENT_1M', 'DUBAI_ASIA1M', '난방유_선물_NYMEX', '천연가스_선물_NYMEX', '가스오일_선물_IPE',\n '천연가스_선물_IPE', '금_선물', '은_선물', '알루미늄_선물', '전기동_선물', '납_선물', '니켈_선물', '주석_선물', '아연_선물', '10YR BEI', 'T10Y2Y',\n 'HY Ef Yield', 'Trade DI', 'VIX', 'USDKRW', 'Eco Policy Uncertainty']]\n return macro_data\n\n\n\ndef load_wics_data():\n WICS대_exposure = process_wics_data(\"./외부데이터/ETF별 업종 exposure.csv\")\n WICS업종 = process_wics_data(\"./외부데이터/WICS 업종별 투자정보 데이터.csv\")\n WICS대 = WICS업종[\n [\n \"에너지\",\n \"소재\",\n \"산업재\",\n \"경기관련소비재\",\n \"필수소비재\",\n \"건강관리\",\n \"금융\",\n \"IT\",\n \"커뮤니케이션서비스\",\n \"유틸리티\",\n ]\n ]\n WICS대 = WICS대.T.drop_duplicates().T\n return WICS대, WICS대_exposure\n\n\n\ndef features_from_wics(wics):\n \"\"\"\n wics : WICS대 (from load_wics_data())\n \"\"\"\n wics_price = wics.xs(\"종가지수\", level=1, axis=1)\n momentums = get_moving_features(wics_price, type='price')\n\n wics_trd_volume = wics.xs(\"거래대금\", level=1, axis=1)\n trd_volumes = get_moving_features(wics_trd_volume, type='volume')\n wics_retail_volume = wics.xs(\"개인 순매수대금(일간)\", level=1, axis=1).fillna(0)\n retail_volumes = get_moving_features(wics_retail_volume, type='volume')\n wics_for_volume = wics.xs(\"외국인총합계순매수대금(일간)\", level=1, axis=1).fillna(0)\n for_volumes = get_moving_features(wics_for_volume, type='volume')\n wics_inst_volume = wics.xs(\"기관 순매수대금(일간)\", level=1,axis=1).fillna(0)\n inst_volumes = get_moving_features(wics_inst_volume, type='volume')\n\n wics_pe = wics.xs(\"P/E(FY0)\", level=1,axis=1)\n pe_scale = wics_pe.resample('M').last().apply(lambda X: minmaxscale(X), axis=1)\n\n wics_fwd_pe = wics.xs(\"P/E(Fwd.12M)\", level=1,axis=1)\n fwd_pe_changes = get_moving_features(wics_fwd_pe, type='fwd')\n wics_fwd_eps = wics.xs(\"EPS(Fwd.12M, 지배)\", level=1,axis=1)\n fwd_eps_changes =get_moving_features(wics_fwd_eps, type='fwd')\n\n size_ = wics.xs(\"시가총액\", level=1,axis=1).resample('M').last()\n\n features = {\n \"macro\": load_macro_data(),\n \"size\": size_,\n \"mom_1m\": momentums[0],\n \"mom_3m\": momentums[1],\n \"mom_6m\": momentums[2],\n \"mom_1y\": momentums[3],\n \"trd_1m\": trd_volumes[0],\n \"trd_3m\": trd_volumes[1],\n \"trd_6m\": trd_volumes[2],\n \"trd_1y\": trd_volumes[3],\n \"retail_trd_1m\": retail_volumes[0],\n \"retail_trd_3m\": retail_volumes[1],\n \"retail_trd_6m\": retail_volumes[2],\n \"retail_trd_1y\": retail_volumes[3],\n \"for_trd_1m\": for_volumes[0],\n \"for_trd_3m\": for_volumes[1],\n \"for_trd_6m\": for_volumes[2],\n \"for_trd_1y\": for_volumes[3],\n \"inst_trd_1m\": inst_volumes[0],\n \"inst_trd_3m\": inst_volumes[1],\n \"inst_trd_6m\": inst_volumes[2],\n \"inst_trd_1y\": inst_volumes[3],\n \"fwd_pe_1m\": fwd_pe_changes[0],\n \"fwd_pe_3m\": fwd_pe_changes[1],\n \"fwd_eps_1m\": fwd_eps_changes[0],\n \"fwd_eps_3m\": fwd_eps_changes[1],\n \"pe\": pe_scale,\n }\n\n return wics_price, features\n\n\ndef combination_set(pair, start, end, price, features):\n \"\"\"\n :param pair: WICS대분류 pair\n :param start: 기간\n :param end: 기간\n :param price: wics_prices (from features_from_wics())\n :param features: features (from features_from_wics())\n \"\"\"\n comb_price = price[list(pair)]\n comb_ret = (comb_price.resample('m').last() / comb_price.resample('m').first()).loc[start:end]\n\n feature_table = features['macro'].loc[start:end]\n for key in list(features.keys())[1:6]:\n feature_table[key] = features[key].apply(lambda x: (x[pair[0]] / x[pair[1]]), axis=1).loc[start:end]\n for key in list(features.keys())[6:]:\n feature_table[key] = features[key].apply(lambda x: (x[pair[0]] - x[pair[1]]), axis=1).loc[start:end]\n\n comb_ret['winner'] = comb_ret.apply(\n lambda x: comb_ret.columns[0] if (x[comb_ret.columns[0]] > x[comb_ret.columns[1]]) else comb_ret.columns[1],\n axis=1)\n\n feature_table = feature_table.replace([-np.inf, np.inf], np.nan).fillna(method='ffill')\n comb_ret = comb_ret.replace([-np.inf, np.inf], np.nan).fillna(method='ffill')\n\n feature_table = feature_table.shift(1).iloc[1:]\n comb_ret = comb_ret.iloc[1:]\n\n X_data = feature_table\n y_data = comb_ret[['winner']].astype('category')\n\n return X_data, y_data\n\ndef load_dataset():\n WICS대,_ = load_wics_data()\n price, features = features_from_wics(WICS대)\n columns = ['에너지', '소재', '산업재', '경기관련소비재', '필수소비재', '건강관리', '금융', 'IT', '커뮤니케이션서비스', '유틸리티']\n pairs = list(combinations(columns, 2))\n total_dataset = {pair : combination_set(pair,'2011-12','2021-05', price, features) for pair in pairs}\n return total_dataset\n"
] | [
[
"pandas.to_datetime",
"pandas.read_csv"
]
] |
haideraltahan/datasets | [
"aad5c7ea705949d20817fcc49a892bb2a21532f0"
] | [
"tensorflow_datasets/testing/starcraft.py"
] | [
"# coding=utf-8\n# Copyright 2019 The TensorFlow Datasets 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\"\"\"Tool for preparing test example of Starcraft dataset.\n\n\n./starcraft --resolution=64 --output_file=test.tfrecords\n./starcraft --resolution=64 --output_file=train_0.tfrecords\n./starcraft --resolution=64 --output_file=train_1.tfrecords\n./starcraft --resolution=64 --output_file=valid.tfrecords\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom absl import app\nfrom absl import flags\nimport numpy as np\nimport png\nimport six\nimport tensorflow as tf\n\nFLAGS = flags.FLAGS\n\nflags.DEFINE_integer(\"resolution\", 64, \"Resolution of the video.\")\nflags.DEFINE_string(\"output_file\", None, \"Path to the output file.\")\n\n\ndef main(argv):\n if len(argv) > 1:\n raise tf.app.UsageError(\"Too many command-line arguments.\")\n\n writer = tf.io.TFRecordWriter(FLAGS.output_file)\n\n feature_list = {}\n frame_list = []\n for _ in range(20):\n # generate 20 frames.\n png_image = six.StringIO()\n png.from_array(\n np.random.randint(\n low=0,\n high=255,\n size=(FLAGS.resolution, FLAGS.resolution, 3),\n dtype=np.uint8), \"RGB\").save(png_image)\n frame_list.append(\n tf.train.Feature(\n bytes_list=tf.train.BytesList(value=[png_image.getvalue()])))\n png_image.close()\n\n feature_list[\"rgb_screen\"] = tf.train.FeatureList(feature=frame_list)\n\n context_feature = {}\n context_feature[\"game_duration_loops\"] = tf.train.Feature(\n int64_list=tf.train.Int64List(value=[20]))\n context_feature[\"game_duration_seconds\"] = tf.train.Feature(\n float_list=tf.train.FloatList(value=[20.0]))\n context_feature[\"n_steps\"] = tf.train.Feature(\n int64_list=tf.train.Int64List(value=[20]))\n context_feature[\"screen_size\"] = tf.train.Feature(\n int64_list=tf.train.Int64List(value=[FLAGS.resolution, FLAGS.resolution]))\n\n example = tf.train.SequenceExample(\n feature_lists=tf.train.FeatureLists(feature_list=feature_list),\n context=tf.train.Features(feature=context_feature))\n writer.write(example.SerializeToString())\n writer.close()\n\n\nif __name__ == \"__main__\":\n app.run(main)\n"
] | [
[
"tensorflow.train.FloatList",
"tensorflow.train.Int64List",
"tensorflow.train.Features",
"tensorflow.train.FeatureList",
"numpy.random.randint",
"tensorflow.io.TFRecordWriter",
"tensorflow.app.UsageError",
"tensorflow.train.FeatureLists"
]
] |
zhao-david/ACORE-LFI | [
"91de88b77f0be110e42ed91bbb7a50b7ca83319a",
"91de88b77f0be110e42ed91bbb7a50b7ca83319a",
"91de88b77f0be110e42ed91bbb7a50b7ca83319a"
] | [
"acore/classifier_cov_pow_toy_pvalue.py",
"acore/classifier_power_multid_truth.py",
"acore/tests/test_sampling_mechanisms.py"
] | [
"from warnings import simplefilter\nsimplefilter(action='ignore', category=FutureWarning)\n\nimport numpy as np\nimport argparse\nimport pandas as pd\nfrom tqdm.auto import tqdm\nfrom datetime import datetime\nfrom sklearn.metrics import log_loss\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n\nfrom utils.functions import train_clf, compute_statistics_single_t0, clf_prob_value, compute_bayesfactor_single_t0, \\\n odds_ratio_loss, train_pvalue_clf\nfrom models.toy_poisson import ToyPoissonLoader\nfrom models.toy_gmm import ToyGMMLoader\nfrom models.toy_gamma import ToyGammaLoader\nfrom or_classifiers.toy_example_list import classifier_dict, classifier_dict_mlpcomp, classifier_pvalue_dict\n\nmodel_dict = {\n 'poisson': ToyPoissonLoader,\n 'gmm': ToyGMMLoader,\n 'gamma': ToyGammaLoader\n}\n\n\ndef main(run, rep, b, b_prime, alpha, t0_val, sample_size_obs, test_statistic, mlp_comp=False,\n monte_carlo_samples=500, debug=False, seed=7, size_check=1000, verbose=False, marginal=False,\n size_marginal=1000, guided_sim=False, guided_sample=1000, empirical_marginal=True):\n\n # Changing values if debugging\n b = b if not debug else 100\n b_prime = b_prime if not debug else 100\n size_check = size_check if not debug else 100\n rep = rep if not debug else 2\n model_obj = model_dict[run](marginal=marginal, size_marginal=size_marginal, empirical_marginal=empirical_marginal)\n classifier_dict_run = classifier_dict_mlpcomp if mlp_comp else classifier_dict\n\n # Get the correct functions\n msnh_sampling_func = model_obj.sample_msnh_algo5\n grid_param = model_obj.grid\n gen_obs_func = model_obj.sample_sim\n gen_sample_func = model_obj.generate_sample\n gen_param_fun = model_obj.sample_param_values\n t0_grid = model_obj.pred_grid\n tp_func = model_obj.compute_exact_prob\n\n # Creating sample to check entropy about\n np.random.seed(seed)\n sample_check = gen_sample_func(sample_size=size_check, marginal=marginal)\n theta_vec = sample_check[:, :model_obj.d]\n x_vec = sample_check[:, (model_obj.d + 1):]\n bern_vec = sample_check[:, model_obj.d]\n\n true_prob_vec = tp_func(theta_vec=theta_vec, x_vec=x_vec)\n entropy_est = -np.average([np.log(true_prob_vec[kk]) if el == 1\n else np.log(1 - true_prob_vec[kk])\n for kk, el in enumerate(bern_vec)])\n\n # Loop over repetitions and classifiers\n # Each time we train the different classifiers, we build the intervals and we record\n # whether the point is in or not.\n out_val = []\n out_cols = ['test_statistic', 'b_prime', 'b', 'classifier', 'classifier_pvalue', 'run', 'rep', 'sample_size_obs',\n 'cross_entropy_loss', 'cross_entropy_loss_pvalue', 't0_true_val', 'theta_0_current', 'on_true_t0',\n 'estimated_pvalue', 'in_confint', 'out_confint', 'size_CI', 'true_entropy', 'or_loss_value',\n 'monte_carlo_samples', 'guided_sim', 'empirical_marginal', 'guided_sample']\n pbar = tqdm(total=rep, desc='Toy Example for Simulations, n=%s, b=%s' % (sample_size_obs, b))\n rep_counter = 0\n not_update_flag = False\n while rep_counter < rep:\n # Generates samples for each t0 values, so to be able to check both coverage and power\n x_obs = gen_obs_func(sample_size=sample_size_obs, true_param=t0_val)\n\n # Train the classifier for the odds\n clf_odds_fitted = {}\n clf_pvalue_fitted = {}\n for clf_name, clf_model in sorted(classifier_dict_run.items(), key=lambda x: x[0]):\n clf_odds = train_clf(sample_size=b, clf_model=clf_model, gen_function=gen_sample_func,\n clf_name=clf_name, nn_square_root=True)\n if verbose:\n print('----- %s Trained' % clf_name)\n\n if test_statistic == 'acore':\n tau_obs = np.array([\n compute_statistics_single_t0(\n clf=clf_odds, obs_sample=x_obs, t0=theta_0, grid_param_t1=grid_param,\n d=model_obj.d, d_obs=model_obj.d_obs) for theta_0 in t0_grid])\n elif test_statistic == 'avgacore':\n tau_obs = np.array([\n compute_bayesfactor_single_t0(\n clf=clf_odds, obs_sample=x_obs, t0=theta_0, gen_param_fun=gen_param_fun,\n d=model_obj.d, d_obs=model_obj.d_obs, log_out=False) for theta_0 in t0_grid])\n elif test_statistic == 'logavgacore':\n tau_obs = np.array([\n compute_bayesfactor_single_t0(\n clf=clf_odds, obs_sample=x_obs, t0=theta_0, gen_param_fun=gen_param_fun,\n d=model_obj.d, d_obs=model_obj.d_obs, log_out=True) for theta_0 in t0_grid])\n else:\n raise ValueError('The variable test_statistic needs to be either acore, avgacore, logavgacore.'\n ' Currently %s' % test_statistic)\n\n # Calculating cross-entropy\n est_prob_vec = clf_prob_value(clf=clf_odds, x_vec=x_vec, theta_vec=theta_vec, d=model_obj.d,\n d_obs=model_obj.d_obs)\n loss_value = log_loss(y_true=bern_vec, y_pred=est_prob_vec)\n\n # Calculating or loss\n or_loss_value = odds_ratio_loss(clf=clf_odds, x_vec=x_vec, theta_vec=theta_vec,\n bern_vec=bern_vec, d=1, d_obs=1)\n clf_odds_fitted[clf_name] = (tau_obs, loss_value, or_loss_value)\n\n # Train the P-value regression algorithm for confidence levels\n\n if guided_sim:\n # Commenting the above -- we now sample a set of thetas from the parameter (of size guided_sample)\n # budget, then resample them according to the odds values, fit a gaussian and then sample the\n # datasets from that.\n theta_mat_sample = gen_param_fun(sample_size=guided_sample)\n\n if test_statistic == 'acore':\n stats_sample = np.apply_along_axis(arr=theta_mat_sample.reshape(-1, 1), axis=1,\n func1d=lambda row: compute_statistics_single_t0(\n clf=clf_odds,\n obs_sample=x_obs,\n t0=row,\n grid_param_t1=grid_param,\n d=model_obj.d,\n d_obs=model_obj.d_obs\n ))\n elif test_statistic == 'avgacore':\n stats_sample = np.apply_along_axis(arr=theta_mat_sample.reshape(-1, 1), axis=1,\n func1d=lambda row: compute_bayesfactor_single_t0(\n clf=clf_odds,\n obs_sample=x_obs,\n t0=row,\n gen_param_fun=gen_param_fun,\n d=model_obj.d,\n d_obs=model_obj.d_obs,\n monte_carlo_samples=monte_carlo_samples\n ))\n elif test_statistic == 'logavgacore':\n stats_sample = np.apply_along_axis(arr=theta_mat_sample.reshape(-1, 1), axis=1,\n func1d=lambda row: compute_bayesfactor_single_t0(\n clf=clf_odds,\n obs_sample=x_obs,\n t0=row,\n gen_param_fun=gen_param_fun,\n d=model_obj.d,\n d_obs=model_obj.d_obs,\n monte_carlo_samples=monte_carlo_samples,\n log_out=True\n ))\n else:\n raise ValueError('The variable test_statistic needs to be either acore, avgacore, logavgacore.'\n ' Currently %s' % test_statistic)\n\n # If there are log-odds, then some of the values might be negative, so we need to exponentiate them\n # so to make sure that the large negative numbers are counted correctly (i.e. as very low probability,\n # not probabilities with large magnitudes).\n if test_statistic in ['acore', 'logavgacore']:\n stats_sample = np.exp(stats_sample)\n stats_sample = stats_sample/np.sum(stats_sample)\n theta_mat_gaussian_fit = np.random.choice(a=theta_mat_sample, p=stats_sample.reshape(-1, ),\n size=guided_sample)\n std_gaussian_fit = np.std(theta_mat_gaussian_fit) if np.std(theta_mat_gaussian_fit) == 0.0 else 1.0\n theta_mat = np.clip(\n a=np.random.normal(size=b_prime, loc=np.mean(theta_mat_gaussian_fit),\n scale=std_gaussian_fit),\n a_min=model_obj.low_int, a_max=model_obj.high_int)\n sample_mat = np.apply_along_axis(arr=theta_mat.reshape(-1, 1), axis=1,\n func1d=lambda row: gen_obs_func(sample_size=sample_size_obs,\n true_param=row))\n else:\n # Generate a matrix with values for both the sampled thetas as the actual samples\n theta_mat, sample_mat = msnh_sampling_func(b_prime=b_prime, sample_size=sample_size_obs)\n\n full_mat = np.hstack((theta_mat.reshape(-1, 1), sample_mat))\n if test_statistic == 'acore':\n stats_mat_generated = np.apply_along_axis(arr=full_mat, axis=1,\n func1d=lambda row: compute_statistics_single_t0(\n clf=clf_odds,\n obs_sample=row[model_obj.d:],\n t0=row[:model_obj.d],\n grid_param_t1=grid_param,\n d=model_obj.d,\n d_obs=model_obj.d_obs\n ))\n stats_mat_observed = np.apply_along_axis(arr=full_mat, axis=1,\n func1d=lambda row: compute_statistics_single_t0(\n clf=clf_odds,\n obs_sample=x_obs,\n t0=row[:model_obj.d],\n grid_param_t1=grid_param,\n d=model_obj.d,\n d_obs=model_obj.d_obs\n ))\n elif test_statistic == 'avgacore':\n stats_mat_generated = np.apply_along_axis(arr=full_mat, axis=1,\n func1d=lambda row: compute_bayesfactor_single_t0(\n clf=clf_odds,\n obs_sample=row[model_obj.d:],\n t0=row[:model_obj.d],\n gen_param_fun=gen_param_fun,\n d=model_obj.d,\n d_obs=model_obj.d_obs,\n monte_carlo_samples=monte_carlo_samples\n ))\n stats_mat_observed = np.apply_along_axis(arr=full_mat, axis=1,\n func1d=lambda row: compute_bayesfactor_single_t0(\n clf=clf_odds,\n obs_sample=x_obs,\n t0=row[:model_obj.d],\n gen_param_fun=gen_param_fun,\n d=model_obj.d,\n d_obs=model_obj.d_obs,\n monte_carlo_samples=monte_carlo_samples\n ))\n elif test_statistic == 'logavgacore':\n stats_mat_generated = np.apply_along_axis(arr=full_mat, axis=1,\n func1d=lambda row: compute_bayesfactor_single_t0(\n clf=clf_odds,\n obs_sample=row[model_obj.d:],\n t0=row[:model_obj.d],\n gen_param_fun=gen_param_fun,\n d=model_obj.d,\n d_obs=model_obj.d_obs,\n monte_carlo_samples=monte_carlo_samples,\n log_out=True\n ))\n stats_mat_observed = np.apply_along_axis(arr=full_mat, axis=1,\n func1d=lambda row: compute_bayesfactor_single_t0(\n clf=clf_odds,\n obs_sample=x_obs,\n t0=row[:model_obj.d],\n gen_param_fun=gen_param_fun,\n d=model_obj.d,\n d_obs=model_obj.d_obs,\n monte_carlo_samples=monte_carlo_samples,\n log_out=True\n ))\n else:\n raise ValueError('The variable test_statistic needs to be either acore, avgacore, logavgacore.'\n ' Currently %s' % test_statistic)\n\n if np.any(np.isnan(stats_mat_generated)) or not np.all(np.isfinite(stats_mat_generated)) or \\\n np.any(np.isnan(stats_mat_observed)) or not np.all(np.isfinite(stats_mat_observed)):\n not_update_flag = True\n break\n\n # Comparing the two vectors of values\n clf_pvalue_fitted[clf_name] = {}\n indicator_vec = np.greater(stats_mat_observed, stats_mat_generated).astype(int)\n for clf_name_pvalue, clf_model_pvalue in sorted(classifier_pvalue_dict.items(), key=lambda x: x[0]):\n\n # If there the indicator_vec is either all 0 or all 1, do not fit a classifier or sklearn will throw\n # an error out. Just return the class.\n if sum(indicator_vec) <= 1 or sum(indicator_vec) >= len(indicator_vec) - 1:\n pval_pred = np.repeat(sum(indicator_vec) / len(indicator_vec), b_prime)\n loss_value_pval = np.nan\n else:\n clf_pvalue = train_pvalue_clf(clf_model=clf_model_pvalue, X=theta_mat.reshape(-1, model_obj.d),\n y=indicator_vec.reshape(-1, ), clf_name=clf_name_pvalue,\n nn_square_root=True)\n pval_pred = clf_pvalue.predict_proba(t0_grid.reshape(-1, model_obj.d))[:, 1]\n theta_mat_pred = clf_pvalue.predict_proba(theta_mat.reshape(-1, model_obj.d))[:, 1]\n loss_value_pval = log_loss(y_true=indicator_vec, y_pred=theta_mat_pred)\n clf_pvalue_fitted[clf_name][clf_name_pvalue] = (pval_pred, loss_value_pval)\n\n # If there were some problems in calculating the statistics, get out of the loop\n if not_update_flag:\n not_update_flag = False\n continue\n\n # At this point all it's left is to record\n for clf_name, (tau_obs_val, cross_ent_loss, or_loss_value) in clf_odds_fitted.items():\n for clf_name_qr, (pvalue_val, pvalue_celoss_val) in clf_pvalue_fitted[clf_name].items():\n size_temp = np.mean((pvalue_val > alpha).astype(int))\n for kk, theta_0_current in enumerate(t0_grid):\n out_val.append([\n test_statistic, b_prime, b, clf_name, clf_name_qr, run, rep_counter, sample_size_obs,\n cross_ent_loss, pvalue_celoss_val, t0_val, theta_0_current, int(t0_val == theta_0_current),\n pvalue_val[kk], int(pvalue_val[kk] > alpha),\n int(pvalue_val[kk] <= alpha), size_temp, entropy_est, or_loss_value,\n monte_carlo_samples, int(guided_sim), int(empirical_marginal), guided_sample\n ])\n pbar.update(1)\n rep_counter += 1\n\n # Saving the results\n out_df = pd.DataFrame.from_records(data=out_val, index=range(len(out_val)), columns=out_cols)\n out_dir = 'sims/classifier_cov_pow_toy/'\n out_filename = 'classifier_reps_cov_pow_toy_pvalues_%steststats_%s_%sB_%sBprime_%s_%srep_alpha%s_sampleobs%s_t0val%s%s_%s.csv' % (\n test_statistic, 'mlp_comp' if mlp_comp else 'toyclassifiers', b, b_prime, run, rep,\n str(alpha).replace('.', '-'), sample_size_obs,\n str(t0_val).replace('.', '-'),\n '_empirmarg' if empirical_marginal else '',\n datetime.strftime(datetime.today(), '%Y-%m-%d-%H-%M')\n )\n out_df.to_csv(out_dir + out_filename)\n\n # Print results\n cov_df = out_df[out_df['on_true_t0'] == 1][['classifier', 'classifier_pvalue', 'in_confint',\n 'cross_entropy_loss', 'cross_entropy_loss_pvalue', 'size_CI']]\n print(cov_df.groupby(['classifier', 'classifier_pvalue']).agg({'in_confint': [np.average],\n 'size_CI': [np.average, np.std],\n 'cross_entropy_loss': [np.average],\n 'cross_entropy_loss_pvalue': [np.average]}))\n\n # Power plots\n out_df['class_combo'] = out_df[['classifier', 'classifier_pvalue']].apply(lambda x: x[0] + '---' + x[1], axis = 1)\n plot_df = out_df[['class_combo', 'theta_0_current', 'out_confint']].groupby(\n ['class_combo', 'theta_0_current']).mean().reset_index()\n fig = plt.figure(figsize=(20, 10))\n sns.lineplot(x='theta_0_current', y='out_confint', hue='class_combo', data=plot_df, palette='cubehelix')\n plt.legend(loc='best', fontsize=25)\n plt.xlabel(r'$\\theta$', fontsize=25)\n plt.ylabel('Power', fontsize=25)\n plt.title(\"Power of Hypothesis Test, B=%s, B'=%s, n=%s, %s\" % (\n b, b_prime, sample_size_obs, run.title()), fontsize=25)\n out_dir = 'images/classifier_cov_pow_toy/'\n outfile_name = 'power_classifier_reps_pvalue_%steststats_%sB_%sBprime_%s_%srep_alpha%s_sampleobs%s_t0val%s_%s.pdf' % (\n test_statistic, b, b_prime, run, rep, str(alpha).replace('.', '-'), sample_size_obs,\n str(t0_val).replace('.', '-'),\n datetime.strftime(datetime.today(), '%Y-%m-%d')\n )\n plt.tight_layout()\n plt.savefig(out_dir + outfile_name)\n plt.close()\n\n\nif __name__ == '__main__':\n\n parser = argparse.ArgumentParser()\n parser.add_argument('--seed', action=\"store\", type=int, default=7,\n help='Random State')\n parser.add_argument('--rep', action=\"store\", type=int, default=10,\n help='Number of Repetitions for calculating the Pinball loss')\n parser.add_argument('--b', action=\"store\", type=int, default=5000,\n help='Sample size to train the classifier for calculating odds')\n parser.add_argument('--b_prime', action=\"store\", type=int, default=1000,\n help='Sample size to train the quantile regression algorithm')\n parser.add_argument('--marginal', action='store_true', default=False,\n help='Whether we are using a parametric approximation of the marginal or'\n 'the baseline reference G')\n parser.add_argument('--alpha', action=\"store\", type=float, default=0.1,\n help='Statistical confidence level')\n parser.add_argument('--run', action=\"store\", type=str, default='poisson',\n help='Problem to run')\n parser.add_argument('--debug', action='store_true', default=False,\n help='If true, a very small value for the sample sizes is fit to make sure the'\n 'file can run quickly for debugging purposes')\n parser.add_argument('--verbose', action='store_true', default=False,\n help='If true, logs are printed to the terminal')\n parser.add_argument('--sample_size_obs', action=\"store\", type=int, default=10,\n help='Sample size of the actual observed data.')\n parser.add_argument('--t0_val', action=\"store\", type=float, default=10.0,\n help='True parameter which generates the observed dataset')\n parser.add_argument('--size_marginal', action=\"store\", type=int, default=1000,\n help='Sample size of the actual marginal distribution, if marginal is True.')\n parser.add_argument('--monte_carlo_samples', action=\"store\", type=int, default=500,\n help='Sample size for the calculation of the avgacore and logavgacore statistic.')\n parser.add_argument('--test_statistic', action=\"store\", type=str, default='acore',\n help='Test statistic to compute confidence intervals. Can be acore|avgacore|logavgacore')\n parser.add_argument('--mlp_comp', action='store_true', default=False,\n help='If true, we compare different MLP training algorithm.')\n parser.add_argument('--empirical_marginal', action='store_true', default=False,\n help='Whether we are sampling directly from the empirical marginal for G')\n parser.add_argument('--guided_sim', action='store_true', default=False,\n help='If true, we guided the sampling for the B prime in order to get meaningful results.')\n parser.add_argument('--guided_sample', action=\"store\", type=int, default=2500,\n help='The sample size to be used for the guided simulation. Only used if guided_sim is True.')\n argument_parsed = parser.parse_args()\n\n # b_vec = [100, 500, 1000]\n # for b_val in b_vec:\n main(\n run=argument_parsed.run,\n rep=argument_parsed.rep,\n marginal=argument_parsed.marginal,\n b=argument_parsed.b,\n b_prime=argument_parsed.b_prime,\n alpha=argument_parsed.alpha,\n debug=argument_parsed.debug,\n sample_size_obs=argument_parsed.sample_size_obs,\n t0_val=argument_parsed.t0_val,\n seed=argument_parsed.seed,\n verbose=argument_parsed.verbose,\n size_marginal=argument_parsed.size_marginal,\n monte_carlo_samples=argument_parsed.monte_carlo_samples,\n test_statistic=argument_parsed.test_statistic,\n mlp_comp=argument_parsed.mlp_comp,\n empirical_marginal=argument_parsed.empirical_marginal,\n guided_sim=argument_parsed.guided_sim,\n guided_sample=argument_parsed.guided_sample\n )\n",
"from warnings import simplefilter\nsimplefilter(action='ignore', category=FutureWarning)\n\nimport numpy as np\nimport argparse\nimport pandas as pd\nfrom tqdm.auto import tqdm\nfrom datetime import datetime\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n\nfrom utils.functions import compute_exact_tau, compute_exact_tau_distr\nfrom models.toy_gmm_multid import ToyGMMMultiDLoader\n\nmodel_dict = {\n 'gmm': ToyGMMMultiDLoader\n}\n\n\ndef main(d_obs, run, rep, alpha, sample_size_obs, n_sampled_true_tau, debug=False, seed=7, verbose=False,\n marginal=False, size_marginal=1000, size_check=10000):\n\n # Changing values if debugging\n rep = rep if not debug else 2\n n_sampled_true_tau = n_sampled_true_tau if not debug else 10\n model_obj = model_dict[run](d_obs=d_obs, marginal=marginal, size_marginal=size_marginal)\n\n # Get the correct functions\n grid_param = model_obj.grid\n gen_obs_func = model_obj.sample_sim\n gen_sample_func = model_obj.generate_sample\n or_func = model_obj.compute_exact_or\n t0_grid = model_obj.pred_grid\n tp_func = model_obj.compute_exact_prob\n t0_val = model_obj.true_param\n\n # Loop over repetitions and classifiers\n # Each time we train the different classifiers, we build the intervals and we record\n # whether the point is in or not.\n np.random.seed(seed)\n out_val = []\n out_cols = ['d_obs', 'run', 'rep', 'classifier', 'sample_size_obs', 't0_true_val', 'theta_0_current', 'on_true_t0',\n 'in_true_interval', 'size_true_int', 'true_entropy']\n pbar = tqdm(total=rep, desc='Toy Example for Simulations, n=%s' % sample_size_obs)\n for jj in range(rep):\n\n # Creating sample to check entropy about\n sample_check = gen_sample_func(sample_size=size_check, marginal=False)\n theta_vec = sample_check[:, :model_obj.d]\n x_vec = sample_check[:, (model_obj.d + 1):]\n bern_vec = sample_check[:, model_obj.d]\n\n true_prob_vec = tp_func(theta_vec=theta_vec, x_vec=x_vec)\n entropy_est = -np.average([np.log(true_prob_vec[kk]) if el == 1\n else np.log(1 - true_prob_vec[kk])\n for kk, el in enumerate(bern_vec)])\n\n # TRUE CONFIDENCE INTERVAL\n # print('------ Calculate true Confidence Interval')\n # Generates samples for each t0 values, so to be able to check both coverage and power\n x_obs = gen_obs_func(sample_size=sample_size_obs, true_param=t0_val)\n\n # # Calculate the true LRT value\n tau_obs = np.array([compute_exact_tau(\n or_func=or_func, x_obs=x_obs, t0_val=theta_0, t1_linspace=grid_param) for theta_0 in t0_grid])\n\n tau_distr = np.apply_along_axis(arr=t0_grid.reshape(-1, model_obj.d), axis=1,\n func1d=lambda t0: compute_exact_tau_distr(\n gen_obs_func=gen_obs_func, or_func=or_func, t0_val=t0,\n t1_linspace=grid_param, n_sampled=n_sampled_true_tau,\n sample_size_obs=sample_size_obs, d_obs=model_obj.d_obs))\n assert tau_distr.shape == (t0_grid.shape[0], n_sampled_true_tau)\n\n quantile_pred_tau = np.quantile(a=tau_distr, q=alpha, axis=1)\n true_interval = (tau_obs > quantile_pred_tau).astype(int)\n true_interval_size = (np.sum(true_interval) / true_interval.shape[0])\n\n # At this point all it's left is to record\n for kk, theta_0_current in enumerate(t0_grid):\n out_val.append([\n d_obs, run, jj, 'Exact', sample_size_obs,\n t0_val, theta_0_current, int(t0_val == theta_0_current),\n true_interval[kk], true_interval_size, entropy_est\n ])\n pbar.update(1)\n\n # Saving the results\n out_df = pd.DataFrame.from_records(data=out_val, index=range(len(out_val)), columns=out_cols)\n out_dir = 'sims/classifier_power_multid/'\n out_filename = 'truth_classifier_power_multid%s_%s_%srep_alpha%s_sampleobs%s_t0val%s_%ssampletau_%s.csv' % (\n d_obs, run, rep, str(alpha).replace('.', '-'), sample_size_obs,\n str(t0_val).replace('.', '-'), n_sampled_true_tau,\n datetime.strftime(datetime.today(), '%Y-%m-%d')\n )\n out_df.to_csv(out_dir + out_filename)\n\n # Print results\n cov_df = out_df[out_df['on_true_t0'] == 1][['classifier', 'in_true_interval', 'true_entropy', 'size_true_int']]\n print(cov_df.groupby(['classifier']).agg({'in_true_interval': [np.average],\n 'size_true_int': [np.average, np.std],\n 'true_entropy': [np.average, np.std]}))\n\n\nif __name__ == '__main__':\n\n parser = argparse.ArgumentParser()\n parser.add_argument('--seed', action=\"store\", type=int, default=7,\n help='Random State')\n parser.add_argument('--d_obs', action=\"store\", type=int, default=2,\n help='Dimensionality of the observed data (feature space)')\n parser.add_argument('--rep', action=\"store\", type=int, default=10,\n help='Number of Repetitions for calculating the Pinball loss')\n parser.add_argument('--alpha', action=\"store\", type=float, default=0.1,\n help='Statistical confidence level')\n parser.add_argument('--run', action=\"store\", type=str, default='gmm',\n help='Problem to run')\n parser.add_argument('--debug', action='store_true', default=False,\n help='If true, a very small value for the sample sizes is fit to make sure the'\n 'file can run quickly for debugging purposes')\n parser.add_argument('--verbose', action='store_true', default=False,\n help='If true, logs are printed to the terminal')\n parser.add_argument('--sample_size_obs', action=\"store\", type=int, default=10,\n help='Sample size of the actual observed data.')\n parser.add_argument('--n_sampled_true_tau', action=\"store\", type=int, default=100,\n help='Number of Monte Carlo samples for calculating distribution of tau sample.')\n argument_parsed = parser.parse_args()\n\n main(\n d_obs=argument_parsed.d_obs,\n run=argument_parsed.run,\n rep=argument_parsed.rep,\n alpha=argument_parsed.alpha,\n debug=argument_parsed.debug,\n sample_size_obs=argument_parsed.sample_size_obs,\n seed=argument_parsed.seed,\n verbose=argument_parsed.verbose,\n n_sampled_true_tau=argument_parsed.n_sampled_true_tau\n )\n",
"import sys\nsys.path.append(\"..\")\nimport pytest\nimport numpy as np\n\nfrom models.sen_poisson import SenPoissonLoader\nfrom models.toy_gmm import ToyGMMLoader\nfrom scipy.stats import multivariate_normal, norm\n\n\ndef test__camelus_linc_sampling():\n\n np.random.seed(7)\n mean_instrumental = np.repeat(0, 7)\n cov_instrumental = np.diag(np.repeat(1, 7))\n\n instrumental_distr = multivariate_normal(mean=mean_instrumental, cov=cov_instrumental)\n\n # Create sample concat_mat\n concat_mat = np.array([[1.5, 1.5, 0], [0.5, 0.5, 1]])\n obs_value = np.array([1, 2, 3, 4, 5, 6, 7])\n random_sample = np.abs(instrumental_distr.rvs(size=1)).astype(int)\n\n # Sample matrix\n sample_mat_1 = np.apply_along_axis(arr=concat_mat, axis=1,\n func1d=lambda row: obs_value if row[2] else random_sample)\n sample_mat_2 = np.apply_along_axis(arr=concat_mat, axis=1,\n func1d=lambda row: obs_value.reshape(1, 7) if row[2]\n else random_sample.reshape(1, 7)).reshape(-1, 7)\n expected_mat = np.vstack((random_sample.reshape(-1, 7), obs_value.reshape(-1, 7)))\n\n np.testing.assert_array_equal(sample_mat_1, expected_mat)\n np.testing.assert_array_equal(sample_mat_2, expected_mat)\n\n\ndef test__poisson_2d_sampling_msnh():\n\n def sample_msnh_algo5_poisson_two_params(b_prime, sample_size):\n background_vec = np.random.uniform(low=80, high=100,\n size=b_prime).reshape(-1, 1)\n mu_vec = np.random.uniform(low=0, high=20,\n size=b_prime).reshape(-1, 1)\n theta_mat = np.hstack((background_vec, mu_vec))\n assert theta_mat.shape == (b_prime, 2)\n\n sample_mat = np.apply_along_axis(arr=theta_mat, axis=1,\n func1d=lambda row: np.hstack(\n (np.random.poisson(lam=row[0] + row[1], size=sample_size).reshape(-1, 1),\n np.random.poisson(lam=1 * row[0], size=sample_size).reshape(-1, 1))))\n return theta_mat, sample_mat\n\n np.random.seed(7)\n t1, s1 = sample_msnh_algo5_poisson_two_params(100, 10)\n\n model_obj = SenPoissonLoader()\n model_obj.set_reference_g(size_reference=100)\n np.random.seed(7)\n t2, s2 = model_obj.sample_msnh_algo5(100, 10)\n\n np.testing.assert_array_equal(t1, t2)\n np.testing.assert_array_equal(s1, s2)\n\n\ndef test__poisson_2d_sampling():\n\n def generate_sample_poisson_two_params(sample_size, mean_instrumental_poisson, cov_instrumental_poisson,\n p=0.5, marginal=False):\n background_vec = np.random.uniform(low=80, high=100,\n size=sample_size).reshape(-1, 1)\n mu_vec = np.random.uniform(low=0, high=20,\n size=sample_size).reshape(-1, 1)\n theta_mat = np.hstack((background_vec, mu_vec))\n assert theta_mat.shape == (sample_size, 2)\n\n bern_vec = np.random.binomial(n=1, p=p, size=sample_size)\n concat_mat = np.hstack((theta_mat.reshape(-1, 2),\n bern_vec.reshape(-1, 1)))\n\n if marginal:\n raise ValueError('Marginal not implemented for this example')\n else:\n instrumental_distr = multivariate_normal(mean=mean_instrumental_poisson, cov=cov_instrumental_poisson)\n\n sample = np.apply_along_axis(arr=concat_mat, axis=1,\n func1d=lambda row: np.array([\n np.random.poisson(lam=row[0] + row[1], size=1),\n np.random.poisson(lam=1 * row[0], size=1)]).reshape(1, 2) if row[\n 2] else\n np.abs(instrumental_distr.rvs(size=1)).astype(int).reshape(1, 2))\n return np.hstack((concat_mat, sample.reshape(-1, 2)))\n\n model_obj = SenPoissonLoader()\n model_obj.set_reference_g(size_reference=100)\n np.random.seed(7)\n t1 = model_obj.generate_sample(100)\n\n np.random.seed(7)\n t2 = generate_sample_poisson_two_params(100, model_obj.mean_instrumental, model_obj.cov_instrumental)\n\n np.testing.assert_array_equal(t1, t2)\n\n\ndef test__msnh_algo5_gmm():\n\n def gmm_manual_sampling(sample_size, mix_param=0.5, mu_param=[-5, 5], sigma_param=[1, 1]):\n cluster = np.random.binomial(n=1, p=mix_param, size=sample_size)\n means = np.take(mu_param, cluster)\n sigmas = np.take(sigma_param, cluster)\n return np.random.normal(loc=means, scale=sigmas, size=sample_size)\n\n def sample_msnh_algo5_gmm(b_prime, sample_size):\n theta_mat = np.random.uniform(low=0, high=10, size=b_prime).reshape(-1,\n 1)\n sample_mat = np.apply_along_axis(arr=theta_mat, axis=1,\n func1d=lambda row: gmm_manual_sampling(\n sample_size=sample_size, mu_param=[-row, row]))\n full_mat = np.hstack((theta_mat, sample_mat))\n return theta_mat, full_mat\n\n def generate_sample_gmm(sample_size=1000, p=0.5, marginal=False, sample_marginal=1000):\n\n theta_vec = np.random.uniform(low=0, high=10, size=sample_size) # Reference Distribution\n bern_vec = np.random.binomial(n=1, p=p, size=sample_size) # Generating Y_1,...,Y_n\n\n # Chaining in columns the two above and then sample either from F or G\n # according to Y_i for i=1,...,n\n concat_mat = np.hstack((theta_vec.reshape(-1, 1),\n bern_vec.reshape(-1, 1)))\n\n if marginal:\n theta_vec_marg = np.random.uniform(low=0, high=10,\n size=sample_marginal)\n marginal_sample = np.apply_along_axis(arr=theta_vec_marg.reshape(-1, 1), axis=1,\n func1d=lambda row: gmm_manual_sampling(\n sample_size=1, mu_param=[-row, row])).reshape(-1, )\n mean_mle = np.average(marginal_sample)\n std_mle = np.std(marginal_sample)\n instrumental_distr = norm(loc=mean_mle, scale=std_mle)\n else:\n instrumental_distr = norm(loc=0, scale=10)\n\n sample = np.apply_along_axis(arr=concat_mat, axis=1,\n func1d=lambda row: gmm_manual_sampling(\n sample_size=1, mu_param=[-row[0], row[0]]) if row[1] else\n instrumental_distr.rvs(size=1))\n return np.hstack((concat_mat, sample.reshape(-1, 1)))\n\n model_obj = ToyGMMLoader()\n np.random.seed(7)\n t1, s1 = model_obj.sample_msnh_algo5(10, 10)\n\n np.random.seed(7)\n t2, f2 = sample_msnh_algo5_gmm(10, 10)\n\n np.testing.assert_array_equal(t1, t2)\n np.testing.assert_array_equal(np.hstack((t1, s1)), f2)\n\n np.random.seed(7)\n b1 = model_obj.generate_sample(100)\n\n np.random.seed(7)\n b2 = generate_sample_gmm(100)\n\n np.testing.assert_array_equal(b1[:, :2], b2[:, :2])\n np.testing.assert_array_equal(b1[:, 2:], b2[:, 2:])"
] | [
[
"numpy.isnan",
"numpy.greater",
"numpy.log",
"numpy.random.seed",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.savefig",
"numpy.sum",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.close",
"numpy.exp",
"matplotlib.pyplot.figure",
"numpy.mean",
"numpy.std",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.ylabel",
"sklearn.metrics.log_loss",
"numpy.isfinite"
],
[
"numpy.random.seed",
"numpy.quantile",
"numpy.sum",
"numpy.log"
],
[
"numpy.random.normal",
"numpy.array",
"numpy.random.binomial",
"scipy.stats.norm",
"numpy.random.seed",
"numpy.testing.assert_array_equal",
"numpy.random.poisson",
"numpy.take",
"numpy.std",
"scipy.stats.multivariate_normal",
"numpy.apply_along_axis",
"numpy.random.uniform",
"numpy.repeat",
"numpy.hstack",
"numpy.average"
]
] |
onlyrico/AliceMind | [
"a6a070b1610e4c4bfe84ee6c4195b2bc4f725ded"
] | [
"StructVBERT/tasks/vqa.py"
] | [
"# coding=utf-8\n# Copyleft 2019 project LXRT.\n\nimport os\nimport collections\n\nimport torch\nimport torch.nn as nn\nimport logging\nfrom torch.utils.data.dataloader import DataLoader\nfrom tqdm import tqdm\n\nfrom param import args\nfrom lxrt.qa_answer_table import load_lxmert_qa\nfrom tasks.vqa_model import VQAModel\nfrom tasks.vqa_data import VQADataset, VQATorchDataset, VQAEvaluator\n\nDataTuple = collections.namedtuple(\"DataTuple\", 'dataset loader evaluator')\n\nlogging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',\n datefmt='%m/%d/%Y %H:%M:%S',\n level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\ndef get_data_tuple(splits: str, bs:int, shuffle=False, drop_last=False) -> DataTuple:\n dset = VQADataset(splits)\n tset = VQATorchDataset(dset)\n evaluator = VQAEvaluator(dset)\n data_loader = DataLoader(\n tset, batch_size=bs,\n shuffle=shuffle, num_workers=args.num_workers,\n drop_last=drop_last, pin_memory=True\n )\n\n return DataTuple(dataset=dset, loader=data_loader, evaluator=evaluator)\n\nclass WarmupOptimizer(object):\n def __init__(self, _lr_base, optimizer, _data_size, _batch_size):\n self.optimizer = optimizer\n self._step = 0\n self._lr_base = _lr_base\n self._rate = 0\n self._data_size = _data_size\n self._batch_size = _batch_size\n\n def step(self):\n self._step += 1\n rate = self.rate()\n for p in self.optimizer.param_groups:\n p['lr'] = rate\n self._rate = rate\n self.optimizer.step()\n\n def zero_grad(self):\n self.optimizer.zero_grad()\n\n def rate(self, step=None):\n if step is None:\n step = self._step\n if step <= int(self._data_size / self._batch_size * 1):\n r = self._lr_base * 1/4.\n elif step <= int(self._data_size / self._batch_size * 2):\n r = self._lr_base * 2/4.\n elif step <= int(self._data_size / self._batch_size * 3):\n r = self._lr_base * 3/4.\n else:\n r = self._lr_base\n return r\n\ndef adjust_learning_rate(optimizer, decay_rate):\n optimizer._lr_base *= decay_rate\n\nclass VQA:\n def __init__(self):\n # Datasets\n self.train_tuple = get_data_tuple(\n args.train, bs=args.batch_size, shuffle=True, drop_last=True\n )\n if args.valid != \"\":\n self.valid_tuple = get_data_tuple(\n args.valid, bs=256, # for large model\n shuffle=False, drop_last=False\n )\n else:\n self.valid_tuple = None\n \n # Model\n self.model = VQAModel(self.train_tuple.dataset.num_answers)\n self._lr_decay_epoch_list = [8, 10]\n self._lr_decay_rate = 0.2\n\n # Load pre-trained weights\n if args.load_lxmert is not None:\n self.model.lxrt_encoder.load(args.load_lxmert)\n if args.load_lxmert_qa is not None:\n load_lxmert_qa(args.load_lxmert_qa, self.model,\n label2ans=self.train_tuple.dataset.label2ans)\n if args.fix_language_bert:\n assert args.patial_load\n state_dict = torch.load(args.patial_load)\n for k in state_dict.copy():\n if not k.startswith('bert.'):\n state_dict['bert.' + k.replace('gamma', 'weight').replace('beta', 'bias')] = state_dict.pop(k)\n\n # fix bert parameters\n for name, param in self.model.lxrt_encoder.model.named_parameters():\n # if 'pooler' in name: # pooler not fixed\n # continue\n if name in state_dict:\n logger.info('fix param for: {}'.format(name))\n param.requires_grad = False\n\n # GPU options\n self.model = self.model.cuda()\n\n # Loss and Optimizer\n self.bce_loss = nn.BCEWithLogitsLoss()\n if 'bert' in args.optim:\n batch_per_epoch = len(self.train_tuple.loader)\n t_total = int(batch_per_epoch * args.epochs)\n logger.info(\"BertAdam Total Iters: %d\" % t_total)\n from lxrt.optimization import BertAdam\n self.optim = BertAdam(list(self.model.parameters()),\n lr=args.lr,\n warmup=0.1,\n t_total=t_total)\n elif 'adam' in args.optim:\n batch_per_epoch = len(self.train_tuple.loader)\n optim = args.optimizer(filter(lambda p: p.requires_grad, self.model.parameters()), lr=0, betas=(0.9, 0.98), eps=1e-9)\n self.optim = WarmupOptimizer(args.lr, optim, batch_per_epoch * args.batch_size, args.batch_size)\n else:\n self.optim = args.optimizer(self.model.parameters(), args.lr)\n\n if args.amp_type is not None:\n try:\n from apex import amp\n except ImportError:\n raise ImportError(\"Please install apex from https://www.github.com/nvidia/apex to run this example.\")\n self.model, self.optim = amp.initialize(self.model, self.optim, opt_level=args.amp_type)\n\n if args.multiGPU:\n self.model.lxrt_encoder.multi_gpu()\n # Output Directory\n self.output = args.output\n os.makedirs(self.output, exist_ok=True)\n\n def train(self, train_tuple, eval_tuple):\n dset, loader, evaluator = train_tuple\n iter_wrapper = (lambda x: tqdm(x, total=len(loader))) if args.tqdm else (lambda x: x)\n\n best_valid = 0.\n for epoch in range(args.epochs):\n quesid2ans = {}\n if 'adam' in args.optim and epoch in self._lr_decay_epoch_list:\n adjust_learning_rate(self.optim, self._lr_decay_rate)\n for i, (ques_id, feats, boxes, sent, target) in iter_wrapper(enumerate(loader)):\n\n self.model.train()\n self.optim.zero_grad()\n\n feats, boxes, target = feats.cuda(), boxes.cuda(), target.cuda()\n\n logit = self.model(feats, boxes, sent)\n assert logit.dim() == target.dim() == 2\n loss = self.bce_loss(logit, target)\n loss = loss * logit.size(1)\n if args.multiGPU:\n loss = loss.mean() # mean() to average on multi-gpu.\n\n if args.amp_type is not None:\n from apex import amp\n with amp.scale_loss(loss, self.optim) as scaled_loss:\n scaled_loss.backward()\n else:\n loss.backward()\n nn.utils.clip_grad_norm_(self.model.parameters(), args.clip_norm)\n self.optim.step()\n\n score, label = logit.max(1)\n for qid, l in zip(ques_id, label.cpu().numpy()):\n ans = dset.label2ans[l]\n quesid2ans[qid.item()] = ans\n\n log_str = \"\\nEpoch %d: Train %0.2f\\n\" % (epoch, evaluator.evaluate(quesid2ans) * 100.)\n\n if self.valid_tuple is not None: # Do Validation\n valid_score = self.evaluate(eval_tuple)\n if valid_score > best_valid:\n best_valid = valid_score\n self.save(\"BEST\")\n\n log_str += \"Epoch %d: Valid %0.2f\\n\" % (epoch, valid_score * 100.) + \\\n \"Epoch %d: Best %0.2f\\n\" % (epoch, best_valid * 100.)\n\n logger.info(log_str)\n\n with open(self.output + \"/log.log\", 'a') as f:\n f.write(log_str)\n f.flush()\n\n self.save(\"LAST\")\n\n def predict(self, eval_tuple: DataTuple, dump=None):\n \"\"\"\n Predict the answers to questions in a data split.\n\n :param eval_tuple: The data tuple to be evaluated.\n :param dump: The path of saved file to dump results.\n :return: A dict of question_id to answer.\n \"\"\"\n self.model.eval()\n dset, loader, evaluator = eval_tuple\n quesid2ans = {}\n for i, datum_tuple in enumerate(loader):\n ques_id, feats, boxes, sent = datum_tuple[:4] # Avoid seeing ground truth\n with torch.no_grad():\n feats, boxes = feats.cuda(), boxes.cuda()\n logit = self.model(feats, boxes, sent)\n if args.with_score:\n logit = nn.Softmax(dim=1)(logit)\n score, label = logit.max(1)\n if args.with_score:\n for qid, l, s in zip(ques_id, label.cpu().numpy(), score.cpu().numpy()):\n ans = dset.label2ans[l]\n quesid2ans[qid.item()] = (ans, str(s))\n else:\n for qid, l in zip(ques_id, label.cpu().numpy()):\n ans = dset.label2ans[l]\n quesid2ans[qid.item()] = ans\n if dump is not None:\n evaluator.dump_result(quesid2ans, dump)\n return quesid2ans\n\n def evaluate(self, eval_tuple: DataTuple, dump=None):\n \"\"\"Evaluate all data in data_tuple.\"\"\"\n quesid2ans = self.predict(eval_tuple, dump)\n return eval_tuple.evaluator.evaluate(quesid2ans)\n\n @staticmethod\n def oracle_score(data_tuple):\n dset, loader, evaluator = data_tuple\n quesid2ans = {}\n for i, (ques_id, feats, boxes, sent, target) in enumerate(loader):\n _, label = target.max(1)\n for qid, l in zip(ques_id, label.cpu().numpy()):\n ans = dset.label2ans[l]\n quesid2ans[qid.item()] = ans\n return evaluator.evaluate(quesid2ans)\n\n def save(self, name):\n torch.save(self.model.state_dict(),\n os.path.join(self.output, \"%s.pth\" % name))\n\n def load(self, path):\n logger.info(\"Load model from %s\" % path)\n state_dict = torch.load(\"%s.pth\" % path)\n self.model.load_state_dict(state_dict)\n\n\nif __name__ == \"__main__\":\n # Build Class\n vqa = VQA()\n\n # Load VQA model weights\n if args.load is not None:\n vqa.load(args.load)\n\n # Test or Train\n if args.test is not None:\n args.fast = args.tiny = False # Always loading all data in test\n if 'test' in args.test:\n vqa.predict(\n get_data_tuple(args.test, bs=950,\n shuffle=False, drop_last=False),\n dump=os.path.join(args.output, 'test_predict.json')\n )\n elif 'val' in args.test: \n # Since part of valididation data are used in pre-training/fine-tuning,\n # only validate on the minival set.\n result = vqa.evaluate(\n get_data_tuple('minival', bs=950,\n shuffle=False, drop_last=False),\n dump=os.path.join(args.output, 'minival_predict.json')\n )\n logger.info(result)\n else:\n assert False, \"No such test option for %s\" % args.test\n else:\n # print('Splits in Train data:', vqa.train_tuple.dataset.splits)\n logger.info('Splits in Train data: {}'.format(vqa.train_tuple.dataset.splits))\n if vqa.valid_tuple is not None:\n logger.info('Splits in Valid data: {}'.format(vqa.valid_tuple.dataset.splits))\n logger.info(\"Valid Oracle: %0.2f\" % (vqa.oracle_score(vqa.valid_tuple) * 100))\n else:\n logger.info(\"DO NOT USE VALIDATION\")\n vqa.train(vqa.train_tuple, vqa.valid_tuple)\n\n\n"
] | [
[
"torch.utils.data.dataloader.DataLoader",
"torch.nn.Softmax",
"torch.no_grad",
"torch.nn.BCEWithLogitsLoss",
"torch.load"
]
] |
ziniuwan/maed | [
"9e1f1c37eba81da86c8d9c62dc9be41a01abff5b"
] | [
"lib/models/spin.py"
] | [
"\"\"\"\nThis script is brought from https://github.com/nkolot/SPIN\nAdhere to their licence to use this script\n\"\"\"\n\nimport math\nimport torch\nimport numpy as np\nimport os.path as osp\nimport torch.nn as nn\n\nfrom lib.core.config import DATA_DIR\nfrom lib.utils.geometry import rotation_matrix_to_angle_axis, rot6d_to_rotmat\nfrom lib.models.smpl import SMPL, SMPL_MODEL_DIR, H36M_TO_J17, SMPL_MEAN_PARAMS\n\n\nclass Regressor(nn.Module):\n def __init__(self, smpl_mean_params=SMPL_MEAN_PARAMS, feat_dim=2048, hidden_dim=1024, **kwargs):\n super(Regressor, self).__init__()\n\n self.smpl = SMPL(\n SMPL_MODEL_DIR,\n create_transl=False,\n create_global_orient=False,\n create_body_pose=False,\n create_betas=False,\n )\n npose = 24 * 6\n nshape = 10\n\n self.fc1 = nn.Linear(feat_dim + npose + nshape + 3, hidden_dim)\n self.drop1 = nn.Dropout()\n self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n self.drop2 = nn.Dropout()\n self.decpose = nn.Linear(hidden_dim, npose)\n self.decshape = nn.Linear(hidden_dim, nshape)\n self.deccam = nn.Linear(hidden_dim, 3)\n nn.init.xavier_uniform_(self.decpose.weight, gain=0.01)\n nn.init.xavier_uniform_(self.decshape.weight, gain=0.01)\n nn.init.xavier_uniform_(self.deccam.weight, gain=0.01)\n\n mean_params = np.load(smpl_mean_params)\n init_pose = torch.from_numpy(mean_params['pose'][:]).unsqueeze(0)\n init_shape = torch.from_numpy(mean_params['shape'][:].astype('float32')).unsqueeze(0)\n init_cam = torch.from_numpy(mean_params['cam']).unsqueeze(0)\n self.register_buffer('init_pose', init_pose)\n self.register_buffer('init_shape', init_shape)\n self.register_buffer('init_cam', init_cam)\n\n\n def iterative_regress(self, x, init_pose=None, init_shape=None, init_cam=None, n_iter=3):\n nt = x.shape[0]\n\n if init_pose is None:\n init_pose = self.init_pose.expand(nt, -1)\n if init_shape is None:\n init_shape = self.init_shape.expand(nt, -1)\n if init_cam is None:\n init_cam = self.init_cam.expand(nt, -1)\n\n pred_pose = init_pose\n pred_shape = init_shape\n pred_cam = init_cam\n for i in range(n_iter):\n xc = torch.cat([x, pred_pose, pred_shape, pred_cam], 1)\n xc = self.fc1(xc)\n xc = self.drop1(xc)\n xc = self.fc2(xc)\n xc = self.drop2(xc)\n pred_pose = self.decpose(xc) + pred_pose\n pred_shape = self.decshape(xc) + pred_shape\n pred_cam = self.deccam(xc) + pred_cam\n\n return pred_pose, pred_shape, pred_cam\n\n def forward(self, x, seqlen, J_regressor=None,\n init_pose=None, init_shape=None, init_cam=None, n_iter=3, **kwargs):\n nt = x.shape[0]\n N = nt//seqlen\n\n pred_pose, pred_shape, pred_cam = self.iterative_regress(x, init_pose, init_shape, init_cam, n_iter=3)\n output_regress = self.get_output(pred_pose, pred_shape, pred_cam, J_regressor)\n\n return output_regress\n\n\n def get_output(self, pred_pose, pred_shape, pred_cam, J_regressor):\n output = {}\n nt = pred_pose.shape[0]\n pred_rotmat = rot6d_to_rotmat(pred_pose).reshape(nt, -1, 3, 3)\n \n pred_output = self.smpl(\n betas=pred_shape,\n body_pose=pred_rotmat[:, 1:],\n global_orient=pred_rotmat[:, 0].unsqueeze(1),\n pose2rot=False\n )\n pred_vertices = pred_output.vertices[:nt]\n pred_joints = pred_output.joints[:nt]\n if J_regressor is not None:\n J_regressor_batch = J_regressor[None, :].expand(pred_vertices.shape[0], -1, -1).to(pred_vertices.device)\n pred_joints = torch.matmul(J_regressor_batch, pred_vertices)\n pred_keypoints_2d = projection(pred_joints, pred_cam)\n pose = rotation_matrix_to_angle_axis(pred_rotmat.reshape(-1, 3, 3)).reshape(nt, -1)\n output['theta'] = torch.cat([pred_cam, pose, pred_shape], dim=1)\n output['verts'] = pred_vertices\n output['kp_2d'] = pred_keypoints_2d\n output['kp_3d'] = pred_joints\n output['rotmat'] = pred_rotmat\n return output\n\n\ndef projection(pred_joints, pred_camera):\n pred_cam_t = torch.stack([pred_camera[:, 1],\n pred_camera[:, 2],\n 2 * 5000. / (224. * pred_camera[:, 0] + 1e-9)], dim=-1)\n batch_size = pred_joints.shape[0]\n camera_center = torch.zeros(batch_size, 2)\n pred_keypoints_2d = perspective_projection(pred_joints,\n rotation=torch.eye(3).unsqueeze(0).expand(batch_size, -1, -1).to(pred_joints.device),\n translation=pred_cam_t,\n focal_length=5000.,\n camera_center=camera_center)\n # Normalize keypoints to [-1,1]\n pred_keypoints_2d = pred_keypoints_2d / (224. / 2.)\n return pred_keypoints_2d\n\n\ndef perspective_projection(points, rotation, translation,\n focal_length, camera_center):\n \"\"\"\n This function computes the perspective projection of a set of points.\n Input:\n points (bs, N, 3): 3D points\n rotation (bs, 3, 3): Camera rotation\n translation (bs, 3): Camera translation\n focal_length (bs,) or scalar: Focal length\n camera_center (bs, 2): Camera center\n \"\"\"\n batch_size = points.shape[0]\n K = torch.zeros([batch_size, 3, 3], device=points.device)\n K[:,0,0] = focal_length\n K[:,1,1] = focal_length\n K[:,2,2] = 1.\n K[:,:-1, -1] = camera_center\n\n # Transform points\n points = torch.einsum('bij,bkj->bki', rotation, points)\n points = points + translation.unsqueeze(1)\n\n # Apply perspective distortion\n projected_points = points / points[:,:,-1].unsqueeze(-1)\n\n # Apply camera intrinsics\n projected_points = torch.einsum('bij,bkj->bki', K, projected_points)\n\n return projected_points[:, :, :-1]\n"
] | [
[
"torch.zeros",
"torch.nn.Linear",
"torch.nn.Dropout",
"torch.cat",
"torch.stack",
"torch.einsum",
"torch.nn.init.xavier_uniform_",
"numpy.load",
"torch.from_numpy",
"torch.eye",
"torch.matmul"
]
] |
soma2000-lang/colour | [
"bb7ee23ac65e09613af78bd18dd98dffb1a2904a",
"bb7ee23ac65e09613af78bd18dd98dffb1a2904a",
"bb7ee23ac65e09613af78bd18dd98dffb1a2904a"
] | [
"colour/models/rgb/transfer_functions/canon_log.py",
"colour/models/rgb/datasets/p3_d65.py",
"colour/examples/appearance/examples_llab.py"
] | [
"\"\"\"\nCanon Log Encodings\n===================\n\nDefines the *Canon Log* encodings:\n\n- :func:`colour.models.log_encoding_CanonLog`\n- :func:`colour.models.log_decoding_CanonLog`\n- :func:`colour.models.log_encoding_CanonLog2`\n- :func:`colour.models.log_decoding_CanonLog2`\n- :func:`colour.models.log_encoding_CanonLog3`\n- :func:`colour.models.log_decoding_CanonLog3`\n\nNotes\n-----\n- :cite:`Canona` is available as a *Drivers & Downloads* *Software* for\n Windows 10 (x64) *Operating System*, a copy of the archive is hosted at\n this url: https://drive.google.com/open?id=0B_IQZQdc4Vy8ZGYyY29pMEVwZU0\n\nReferences\n----------\n- :cite:`Canona` : Canon. (2016). EOS C300 Mark II - EOS C300 Mark II Input\n Transform Version 2.0 (for Cinema Gamut / BT.2020). Retrieved August 23,\n 2016, from\n https://www.usa.canon.com/internet/portal/us/home/support/details/cameras/cinema-eos/eos-c300-mark-ii\n- :cite:`Thorpe2012a` : Thorpe, L. (2012). CANON-LOG TRANSFER CHARACTERISTIC.\n Retrieved September 25, 2014, from\n http://downloads.canon.com/CDLC/Canon-Log_Transfer_Characteristic_6-20-2012.pdf\n\"\"\"\n\nfrom __future__ import annotations\n\nimport numpy as np\n\nfrom colour.hints import (\n Boolean,\n FloatingOrArrayLike,\n FloatingOrNDArray,\n Integer,\n)\nfrom colour.models.rgb.transfer_functions import full_to_legal, legal_to_full\nfrom colour.utilities import (\n as_float,\n domain_range_scale,\n from_range_1,\n to_domain_1,\n)\n\n__author__ = \"Colour Developers\"\n__copyright__ = \"Copyright (C) 2013-2022 - Colour Developers\"\n__license__ = \"New BSD License - https://opensource.org/licenses/BSD-3-Clause\"\n__maintainer__ = \"Colour Developers\"\n__email__ = \"[email protected]\"\n__status__ = \"Production\"\n\n__all__ = [\n \"log_encoding_CanonLog\",\n \"log_decoding_CanonLog\",\n \"log_encoding_CanonLog2\",\n \"log_decoding_CanonLog2\",\n \"log_encoding_CanonLog3\",\n \"log_decoding_CanonLog3\",\n]\n\n\ndef log_encoding_CanonLog(\n x: FloatingOrArrayLike,\n bit_depth: Integer = 10,\n out_normalised_code_value: Boolean = True,\n in_reflection: Boolean = True,\n) -> FloatingOrNDArray:\n \"\"\"\n Defines the *Canon Log* log encoding curve / opto-electronic transfer\n function.\n\n Parameters\n ----------\n x\n Linear data :math:`x`.\n bit_depth\n Bit depth used for conversion.\n out_normalised_code_value\n Whether the *Canon Log* non-linear data is encoded as normalised code\n values.\n in_reflection\n Whether the light level :math:`x` to a camera is reflection.\n\n Returns\n -------\n :class:`numpy.floating` or :class:`numpy.ndarray`\n *Canon Log* non-linear data.\n\n References\n ----------\n :cite:`Thorpe2012a`\n\n Notes\n -----\n\n +------------+-----------------------+---------------+\n | **Domain** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``x`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n +------------+-----------------------+---------------+\n | **Range** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``clog`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n Examples\n --------\n >>> log_encoding_CanonLog(0.18) * 100 # doctest: +ELLIPSIS\n 34.3389651...\n\n The values of *Table 2 Canon-Log Code Values* table in :cite:`Thorpe2012a`\n are obtained as follows:\n\n >>> x = np.array([0, 2, 18, 90, 720]) / 100\n >>> np.around(log_encoding_CanonLog(x) * (2 ** 10 - 1)).astype(np.int)\n array([ 128, 169, 351, 614, 1016])\n >>> np.around(log_encoding_CanonLog(x, 10, False) * 100, 1)\n array([ 7.3, 12. , 32.8, 62.7, 108.7])\n \"\"\"\n\n x = to_domain_1(x)\n\n if in_reflection:\n x = x / 0.9\n\n with domain_range_scale(\"ignore\"):\n clog = np.where(\n x < log_decoding_CanonLog(0.0730597, bit_depth, False),\n -(0.529136 * (np.log10(-x * 10.1596 + 1)) - 0.0730597),\n 0.529136 * np.log10(10.1596 * x + 1) + 0.0730597,\n )\n\n clog_cv = (\n full_to_legal(clog, bit_depth) if out_normalised_code_value else clog\n )\n\n return as_float(from_range_1(clog_cv))\n\n\ndef log_decoding_CanonLog(\n clog: FloatingOrArrayLike,\n bit_depth: Integer = 10,\n in_normalised_code_value: Boolean = True,\n out_reflection: Boolean = True,\n) -> FloatingOrNDArray:\n \"\"\"\n Defines the *Canon Log* log decoding curve / electro-optical transfer\n function.\n\n Parameters\n ----------\n clog\n *Canon Log* non-linear data.\n bit_depth\n Bit depth used for conversion.\n in_normalised_code_value\n Whether the *Canon Log* non-linear data is encoded with normalised\n code values.\n out_reflection\n Whether the light level :math:`x` to a camera is reflection.\n\n Returns\n -------\n :class:`numpy.floating` or :class:`numpy.ndarray`\n Linear data :math:`x`.\n\n Notes\n -----\n\n +------------+-----------------------+---------------+\n | **Domain** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``clog`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n +------------+-----------------------+---------------+\n | **Range** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``x`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n References\n ----------\n :cite:`Thorpe2012a`\n\n Examples\n --------\n >>> log_decoding_CanonLog(34.338965172606912 / 100) # doctest: +ELLIPSIS\n 0.17999999...\n \"\"\"\n\n clog = to_domain_1(clog)\n\n clog = legal_to_full(clog, bit_depth) if in_normalised_code_value else clog\n\n x = np.where(\n clog < 0.0730597,\n -(10 ** ((0.0730597 - clog) / 0.529136) - 1) / 10.1596,\n (10 ** ((clog - 0.0730597) / 0.529136) - 1) / 10.1596,\n )\n\n if out_reflection:\n x = x * 0.9\n\n return as_float(from_range_1(x))\n\n\ndef log_encoding_CanonLog2(\n x: FloatingOrArrayLike,\n bit_depth: Integer = 10,\n out_normalised_code_value: Boolean = True,\n in_reflection: Boolean = True,\n) -> FloatingOrNDArray:\n \"\"\"\n Defines the *Canon Log 2* log encoding curve / opto-electronic transfer\n function.\n\n Parameters\n ----------\n x\n Linear data :math:`x`.\n bit_depth\n Bit depth used for conversion.\n out_normalised_code_value\n Whether the *Canon Log 2* non-linear data is encoded as normalised\n code values.\n in_reflection\n Whether the light level :math:`x` to a camera is reflection.\n\n Returns\n -------\n :class:`numpy.floating` or :class:`numpy.ndarray`\n *Canon Log 2* non-linear data.\n\n Notes\n -----\n\n +------------+-----------------------+---------------+\n | **Domain** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``x`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n +------------+-----------------------+---------------+\n | **Range** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``clog2`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n References\n ----------\n :cite:`Canona`\n\n Examples\n --------\n >>> log_encoding_CanonLog2(0.18) * 100 # doctest: +ELLIPSIS\n 39.8254694...\n \"\"\"\n\n x = to_domain_1(x)\n\n if in_reflection:\n x = x / 0.9\n\n with domain_range_scale(\"ignore\"):\n clog2 = np.where(\n x < log_decoding_CanonLog2(0.035388128, bit_depth, False),\n -(0.281863093 * (np.log10(-x * 87.09937546 + 1)) - 0.035388128),\n 0.281863093 * np.log10(x * 87.09937546 + 1) + 0.035388128,\n )\n\n clog2_cv = (\n full_to_legal(clog2, bit_depth) if out_normalised_code_value else clog2\n )\n\n return as_float(from_range_1(clog2_cv))\n\n\ndef log_decoding_CanonLog2(\n clog2: FloatingOrArrayLike,\n bit_depth: Integer = 10,\n in_normalised_code_value: Boolean = True,\n out_reflection: Boolean = True,\n) -> FloatingOrNDArray:\n \"\"\"\n Defines the *Canon Log 2* log decoding curve / electro-optical transfer\n function.\n\n Parameters\n ----------\n clog2\n *Canon Log 2* non-linear data.\n bit_depth\n Bit depth used for conversion.\n in_normalised_code_value\n Whether the *Canon Log 2* non-linear data is encoded with normalised\n code values.\n out_reflection\n Whether the light level :math:`x` to a camera is reflection.\n\n Returns\n -------\n :class:`numpy.floating` or :class:`numpy.ndarray`\n Linear data :math:`x`.\n\n Notes\n -----\n\n +------------+-----------------------+---------------+\n | **Domain** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``clog2`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n +------------+-----------------------+---------------+\n | **Range** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``x`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n References\n ----------\n :cite:`Canona`\n\n Examples\n --------\n >>> log_decoding_CanonLog2(39.825469498316735 / 100) # doctest: +ELLIPSIS\n 0.1799999...\n \"\"\"\n\n clog2 = to_domain_1(clog2)\n\n clog2 = (\n legal_to_full(clog2, bit_depth) if in_normalised_code_value else clog2\n )\n\n x = np.where(\n clog2 < 0.035388128,\n -(10 ** ((0.035388128 - clog2) / 0.281863093) - 1) / 87.09937546,\n (10 ** ((clog2 - 0.035388128) / 0.281863093) - 1) / 87.09937546,\n )\n\n if out_reflection:\n x = x * 0.9\n\n return as_float(from_range_1(x))\n\n\ndef log_encoding_CanonLog3(\n x: FloatingOrArrayLike,\n bit_depth: Integer = 10,\n out_normalised_code_value: Boolean = True,\n in_reflection: Boolean = True,\n) -> FloatingOrNDArray:\n \"\"\"\n Defines the *Canon Log 3* log encoding curve / opto-electronic transfer\n function.\n\n Parameters\n ----------\n x\n Linear data :math:`x`.\n bit_depth\n Bit depth used for conversion.\n out_normalised_code_value\n Whether the *Canon Log 3* non-linear data is encoded as normalised code\n values.\n in_reflection\n Whether the light level :math:`x` to a camera is reflection.\n\n Returns\n -------\n :class:`numpy.floating` or :class:`numpy.ndarray`\n *Canon Log 3* non-linear data.\n\n Notes\n -----\n - Introspection of the grafting points by Shaw, N. (2018) shows that the\n *Canon Log 3* IDT was likely derived from its encoding curve as the\n later is grafted at *+/-0.014*::\n\n >>> clog3 = 0.04076162\n >>> (clog3 - 0.073059361) / 2.3069815\n -0.014000000000000002\n >>> clog3 = 0.105357102\n >>> (clog3 - 0.073059361) / 2.3069815\n 0.013999999999999997\n\n +------------+-----------------------+---------------+\n | **Domain** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``x`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n +------------+-----------------------+---------------+\n | **Range** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``clog3`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n References\n ----------\n :cite:`Canona`\n\n Examples\n --------\n >>> log_encoding_CanonLog3(0.18) * 100 # doctest: +ELLIPSIS\n 34.3389369...\n \"\"\"\n\n x = to_domain_1(x)\n\n if in_reflection:\n x = x / 0.9\n\n with domain_range_scale(\"ignore\"):\n clog3 = np.select(\n (\n x\n < log_decoding_CanonLog3(0.04076162, bit_depth, False, False),\n x\n <= log_decoding_CanonLog3(\n 0.105357102, bit_depth, False, False\n ),\n x\n > log_decoding_CanonLog3(0.105357102, bit_depth, False, False),\n ),\n (\n -0.42889912 * np.log10(-x * 14.98325 + 1) + 0.07623209,\n 2.3069815 * x + 0.073059361,\n 0.42889912 * np.log10(x * 14.98325 + 1) + 0.069886632,\n ),\n )\n\n clog3_cv = (\n full_to_legal(clog3, bit_depth) if out_normalised_code_value else clog3\n )\n\n return as_float(from_range_1(clog3_cv))\n\n\ndef log_decoding_CanonLog3(\n clog3: FloatingOrArrayLike,\n bit_depth: Integer = 10,\n in_normalised_code_value: Boolean = True,\n out_reflection: Boolean = True,\n) -> FloatingOrNDArray:\n \"\"\"\n Defines the *Canon Log 3* log decoding curve / electro-optical transfer\n function.\n\n Parameters\n ----------\n clog3\n *Canon Log 3* non-linear data.\n bit_depth\n Bit depth used for conversion.\n in_normalised_code_value\n Whether the *Canon Log 3* non-linear data is encoded with normalised\n code values.\n out_reflection\n Whether the light level :math:`x` to a camera is reflection.\n\n Returns\n -------\n :class:`numpy.floating` or :class:`numpy.ndarray`\n Linear data :math:`x`.\n\n Notes\n -----\n\n +------------+-----------------------+---------------+\n | **Domain** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``clog3`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n +------------+-----------------------+---------------+\n | **Range** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``x`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n References\n ----------\n :cite:`Canona`\n\n Examples\n --------\n >>> log_decoding_CanonLog3(34.338936938868677 / 100) # doctest: +ELLIPSIS\n 0.1800000...\n \"\"\"\n\n clog3 = to_domain_1(clog3)\n\n clog3 = (\n legal_to_full(clog3, bit_depth) if in_normalised_code_value else clog3\n )\n\n x = np.select(\n (clog3 < 0.04076162, clog3 <= 0.105357102, clog3 > 0.105357102),\n (\n -(10 ** ((0.07623209 - clog3) / 0.42889912) - 1) / 14.98325,\n (clog3 - 0.073059361) / 2.3069815,\n (10 ** ((clog3 - 0.069886632) / 0.42889912) - 1) / 14.98325,\n ),\n )\n\n if out_reflection:\n x = x * 0.9\n\n return as_float(from_range_1(x))\n",
"\"\"\"\nP3-D65 Colourspace\n==================\n\nDefines the *P3-D65* colourspace:\n\n- :attr:`colour.models.RGB_COLOURSPACE_P3_D65`.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport numpy as np\nfrom functools import partial\n\nfrom colour.colorimetry import CCS_ILLUMINANTS\nfrom colour.hints import NDArray\nfrom colour.models.rgb import (\n RGB_Colourspace,\n gamma_function,\n normalised_primary_matrix,\n)\n\n__author__ = \"Colour Developers\"\n__copyright__ = \"Copyright (C) 2013-2022 - Colour Developers\"\n__license__ = \"New BSD License - https://opensource.org/licenses/BSD-3-Clause\"\n__maintainer__ = \"Colour Developers\"\n__email__ = \"[email protected]\"\n__status__ = \"Production\"\n\n__all__ = [\n \"PRIMARIES_P3_D65\",\n \"WHITEPOINT_NAME_P3_D65\",\n \"CCS_WHITEPOINT_P3_D65\",\n \"MATRIX_P3_D65_TO_XYZ\",\n \"MATRIX_XYZ_TO_P3_D65\",\n \"RGB_COLOURSPACE_P3_D65\",\n]\n\nPRIMARIES_P3_D65: NDArray = np.array(\n [\n [0.6800, 0.3200],\n [0.2650, 0.6900],\n [0.1500, 0.0600],\n ]\n)\n\"\"\"\n*P3-D65* colourspace primaries.\n\"\"\"\n\nWHITEPOINT_NAME_P3_D65: str = \"D65\"\n\"\"\"\n*P3-D65* colourspace whitepoint name.\n\"\"\"\n\nCCS_WHITEPOINT_P3_D65: NDArray = CCS_ILLUMINANTS[\n \"CIE 1931 2 Degree Standard Observer\"\n][WHITEPOINT_NAME_P3_D65]\n\"\"\"\n*P3-D65* colourspace whitepoint chromaticity coordinates.\n\"\"\"\n\nMATRIX_P3_D65_TO_XYZ: NDArray = normalised_primary_matrix(\n PRIMARIES_P3_D65, CCS_WHITEPOINT_P3_D65\n)\n\"\"\"\n*P3-D65* colourspace to *CIE XYZ* tristimulus values matrix.\n\"\"\"\n\nMATRIX_XYZ_TO_P3_D65: NDArray = np.linalg.inv(MATRIX_P3_D65_TO_XYZ)\n\"\"\"\n*CIE XYZ* tristimulus values to *P3-D65* colourspace matrix.\n\"\"\"\n\nRGB_COLOURSPACE_P3_D65: RGB_Colourspace = RGB_Colourspace(\n \"P3-D65\",\n PRIMARIES_P3_D65,\n CCS_WHITEPOINT_P3_D65,\n WHITEPOINT_NAME_P3_D65,\n MATRIX_P3_D65_TO_XYZ,\n MATRIX_XYZ_TO_P3_D65,\n partial(gamma_function, exponent=1 / 2.6),\n partial(gamma_function, exponent=2.6),\n)\nRGB_COLOURSPACE_P3_D65.__doc__ = \"\"\"\n*P3-D65* colourspace.\n\"\"\"\n",
"\"\"\"\nShowcases *LLAB(l:c)* colour appearance model computations.\n\"\"\"\n\nimport numpy as np\n\nimport colour\nfrom colour.appearance.llab import CAM_ReferenceSpecification_LLAB\nfrom colour.utilities import message_box\n\nmessage_box('\"LLAB(l:c)\" Colour Appearance Model Computations')\n\nXYZ = np.array([19.01, 20.00, 21.78])\nXYZ_0 = np.array([95.05, 100.00, 108.88])\nY_b = 20.0\nL = 318.31\nsurround = colour.VIEWING_CONDITIONS_LLAB[\"ref_average_4_minus\"]\nmessage_box(\n f'Converting to the \"LLAB(l:c)\" colour appearance model specification '\n f\"using given parameters:\\n\\n\"\n f\"\\tXYZ: {XYZ}\\n\"\n f\"\\tXYZ_0: {XYZ_0}\\n\"\n f\"\\tY_b: {Y_b}\\n\"\n f\"\\tL: {L}\\n\"\n f\"\\tsurround: {surround}\"\n)\nspecification = colour.XYZ_to_LLAB(XYZ, XYZ_0, Y_b, L, surround)\nprint(specification)\n\nprint(\"\\n\")\n\nmessage_box(\n 'Broadcasting the current output \"LLAB(l:c)\" colour appearance '\n \"model specification to the reference specification.\\n\"\n \"The intent of this reference specification is to provide names \"\n 'as closest as possible to the \"Mark D. Fairchild\" reference.\\n'\n \"The current output specification is meant to be consistent with \"\n \"the other colour appearance model specification by using same \"\n \"argument names for consistency wherever possible.\"\n)\n\nprint(CAM_ReferenceSpecification_LLAB(*specification.values))\n"
] | [
[
"numpy.log10",
"numpy.where",
"numpy.select"
],
[
"numpy.array",
"numpy.linalg.inv"
],
[
"numpy.array"
]
] |
chaitanyamalaviya/NeuralFactorGraph | [
"6cd664b7edc43d56c6f1165baa7e7625eb0f7cd8"
] | [
"utils.py"
] | [
"from __future__ import division, print_function\nfrom conllu.parser import parse, parse_tree\nfrom tags import Tags, Tag, Label\n\nimport os\nimport re\nimport math\nimport numpy as np\nimport itertools\nimport pdb\nimport pickle\nimport matplotlib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pyplot as plt\n\nimport torch\nfrom torch.autograd import Variable\nimport torch.nn.functional as F\nnp.set_printoptions(threshold=np.nan)\n\n\nFROZEN_TAG = \"__frozen__\"\n\ndef freeze_dict(obj):\n if isinstance(obj, dict):\n dict_items = list(obj.items())\n dict_items.append((FROZEN_TAG, True))\n return tuple([(k, freeze_dict(v)) for k, v in dict_items])\n return obj\n\ndef unfreeze_dict(obj):\n if isinstance(obj, tuple):\n if (FROZEN_TAG, True) in obj:\n out = dict((k, unfreeze_dict(v)) for k, v in obj)\n del out[FROZEN_TAG]\n return out\n return obj\n\n\ndef get_lang_code_dicts():\n \"\"\"\n Returns lang_to_code, code_to_lang dictionaries\n\n \"\"\"\n lang_to_code = {}\n code_to_lang = {}\n bad_chars = \",''\"\n rgx = re.compile('[%s]' % bad_chars)\n\n with open(\"data/lang_codes.txt\") as f:\n data = f.read()\n lines = data.split(\"\\n\")\n split_line = [line.split() for line in lines]\n for line in split_line[:-2]:\n lang = rgx.sub('', line[0])\n code = rgx.sub('', line[2]) \n lang_to_code[lang] = code\n code_to_lang = {v: k for k, v in lang_to_code.iteritems()}\n return lang_to_code, code_to_lang\n\n\ndef read_conll(treebank_path, langs, code_to_lang, train_or_dev, tgt_size=None, test=False):\n \n \"\"\"\n Reads conll formatted file\n\n langs: list of languages\n train: read training data\n returns: dict with data for each language\n as list of tuples of sentences and morph-tags\n \"\"\"\n\n annot_sents = {}\n unique = []\n for lang in langs:\n\n train = train_or_dev if not test else \"test\"\n\n if not test:\n for file in os.listdir(treebank_path + \"UD_\" + code_to_lang[lang]):\n if file.endswith(\"train.conllu\"):\n filepath = os.path.join(treebank_path + \"UD_\" + code_to_lang[lang], file)\n break\n else:\n for file in os.listdir(treebank_path + \"UD_\" + code_to_lang[lang]):\n if file.endswith(\"dev.conllu\"):\n filepath = os.path.join(treebank_path+ \"UD_\" + code_to_lang[lang], file)\n break\n\n with open(filepath) as f:\n data = f.readlines()[:-1]\n data = [line for line in data if line[0]!='#']\n split_data = \" \".join(data).split(\"\\n \\n\")\n ud = [parse(sent)[0] for sent in split_data]\n\n all_text = []\n all_tags = []\n if langs[-1]==lang and tgt_size:\n tgt_size = min(tgt_size, len(ud))\n ud = ud[:tgt_size]\n for sent in ud:\n sent_text = []\n sent_tags = []\n for word in sent:\n word_tags = {}\n if word['feats']:\n word_tags = dict(word['feats'])\n if word['upostag']:\n if word_tags:\n word_tags.update({'POS':word['upostag']})\n else:\n word_tags = {'POS':word['upostag']}\n \n if word_tags:\n word_tags = freeze_dict(word_tags)\n if word_tags not in unique:\n unique.append(word_tags)\n\n sent_text.append(word['form'])\n sent_tags.append(freeze_dict(word_tags))\n\n all_text.append(sent_text)\n all_tags.append(sent_tags)\n\n annot_sents[lang] = [(w, m) for w, m in zip(all_text, all_tags)]\n\n return annot_sents, unique\n\n\ndef addNullLabels(annot_sents, langs, unique_tags):\n\n for lang in langs:\n i = 0\n for w, m in annot_sents[lang]:\n new_tags = []\n for tags in m:\n tag_dict = unfreeze_dict(tags)\n for tag in unique_tags:\n if tag.name not in tag_dict:\n tag_dict[tag.name] = \"NULL\"\n new_tags.append(freeze_dict(tag_dict))\n\n annot_sents[lang][i] = (w, new_tags)\n i += 1\n\n return annot_sents\n\n\ndef sortbylength(data, lang_ids, maxlen=500):\n \"\"\"\n :param data: List of tuples of source sentences and morph tags\n :param lang_ids: List of lang IDs for each sentence\n :param maxlen: Maximum sentence length permitted\n :return: Sorted data and sorted langIDs\n \"\"\"\n src = [elem[0] for elem in data]\n tgt = [elem[1] for elem in data]\n indexed_src = [(i,src[i]) for i in range(len(src))]\n sorted_indexed_src = sorted(indexed_src, key=lambda x: -len(x[1]))\n sorted_src = [item[1] for item in sorted_indexed_src if len(item[1])<maxlen]\n sort_order = [item[0] for item in sorted_indexed_src if len(item[1])<maxlen]\n sorted_tgt = [tgt[i] for i in sort_order]\n sorted_lang_ids = [lang_ids[i] for i in sort_order]\n sorted_data = [(src, tgt) for src, tgt in zip(sorted_src, sorted_tgt)]\n\n return sorted_data, sorted_lang_ids\n\n\ndef get_train_order(training_data, batch_size, startIdx=0):\n \"\"\"\n :param data: List of tuples of source sentences and morph tags\n :return: start idxs of batches\n \"\"\"\n\n lengths = [len(elem[0]) for elem in training_data]\n start_idxs = []\n end_idxs = []\n prev_length=-1\n batch_counter = 0\n\n for i, length in enumerate(lengths, start=startIdx):\n \n if length!=prev_length or batch_counter>batch_size:\n start_idxs.append(i)\n if prev_length!=-1:\n end_idxs.append(i-1)\n batch_counter = 1\n\n batch_counter += 1 \n prev_length = length\n\n end_idxs.append(startIdx + len(lengths)-1)\n\n return [(s,e) for s,e in zip(start_idxs, end_idxs)]\n\ndef find_unique_tags(train_data_tags, null_label=False):\n\n unique_tags = Tags()\n\n for tags in train_data_tags:\n for tag, label in unfreeze_dict(tags).items():\n if not unique_tags.tagExists(tag):\n unique_tags.addTag(tag)\n \n curTag = unique_tags.getTagbyName(tag)\n\n if not curTag.labelExists(label):\n curTag.addLabel(label)\n\n # Add null labels to unseen tags in each tag set\n if null_label:\n for tag in unique_tags:\n tag.addLabel(\"NULL\")\n\n return unique_tags\n\n\ndef plot_heatmap(uniqueTags, weights, kind):\n\n font = {'family' : 'normal',\n 'size' : 14,\n 'weight' : 'bold'}\n\n matplotlib.rc('font', **font)\n\n pairs = list(itertools.combinations(range(uniqueTags.size()), 2))\n\n # weights is a ParameterList\n for k, weight in enumerate(weights):\n if kind==\"pair\":\n i, j = pairs[k]\n tag1 = uniqueTags.getTagbyIdx(i)\n tag2 = uniqueTags.getTagbyIdx(j)\n tag1_labels = [label.name for label in tag1.labels]\n tag2_labels = [label.name for label in tag2.labels]\n \n plt.figure(figsize=(20, 18), dpi=80)\n plt.xticks(range(0, len(tag2_labels)), tag2_labels)\n plt.yticks(range(0, len(tag1_labels)), tag1_labels)\n plt.tick_params(labelsize=25)\n plt.xlabel(tag2.name, fontsize=40)\n plt.ylabel(tag1.name, fontsize=50)\n plt.imshow(weight.data.cpu().numpy(), cmap='Reds', interpolation='nearest')\n plt.savefig(\"figures/\" + tag1.name + \"_\" + tag2.name + \".png\", bbox_inches='tight')\n plt.close()\n \n elif kind==\"trans\":\n tag = uniqueTags.getTagbyIdx(k)\n tag_labels = [label.name for label in tag.labels]\n\n plt.figure(figsize=(20, 18), dpi=80)\n plt.xticks(range(0, len(tag_labels)), tag_labels, rotation=45)\n plt.yticks(range(0, len(tag_labels)), tag_labels)\n plt.tick_params(labelsize=40)\n plt.xlabel(tag.name, fontsize=50)\n plt.ylabel(tag.name, fontsize=50)\n plt.imshow(weight.data.cpu().numpy(), cmap='Greys', interpolation='nearest')\n plt.savefig(\"figures/\" + tag.name + \"_\" + tag.name + \".png\", bbox_inches='tight')\n plt.close()\n\n\ndef get_var(x, gpu=False, volatile=False):\n x = Variable(x, volatile=volatile)\n if gpu:\n x = x.cuda()\n return x\n\ndef prepare_sequence(seq, to_ix, gpu=False):\n if isinstance(to_ix, dict):\n idxs = [to_ix[w] if w in to_ix else to_ix[\"UNK\"] for w in seq]\n elif isinstance(to_ix, list):\n idxs = [to_ix.index(w) if w in to_ix else to_ix.index(\"UNK\") for w in seq]\n tensor = torch.LongTensor(idxs)\n return get_var(tensor, gpu)\n\ndef to_scalar(var):\n # returns a python float\n return var.view(-1).data.tolist()[0]\n\ndef argmax(vec):\n # return the argmax as a python int\n _, idx = torch.max(vec, 1)\n return to_scalar(idx)\n\ndef logSumExp(a, b):\n maxi = np.maximum(a, b)\n aexp = a - maxi\n bexp = b - maxi\n sumOfExp = np.exp(aexp) + np.exp(bexp)\n return maxi + np.log(sumOfExp)\n\ndef logSumExpTensor(vec):\n # vec -> 16, tag_size\n batch_size = vec.size()[0]\n vec = vec.view(batch_size, -1)\n max_score = torch.max(vec, 1)[0]\n max_score_broadcast = max_score.view(-1, 1).expand(-1, vec.size()[1])\n return max_score + \\\n torch.log(torch.sum(torch.exp(vec - max_score_broadcast), 1))\n\ndef logSumExpTensors(a, b):\n\n maxi = torch.max(a, b)\n aexp = a - maxi\n bexp = b - maxi\n sumOfExp = torch.exp(aexp) + torch.exp(bexp)\n return maxi + torch.log(sumOfExp)\n\ndef logDot(a, b, redAxis=None):\n\n if redAxis==1:\n b = b.transpose()\n\n max_a = np.amax(a)\n max_b = np.amax(b)\n\n C = np.dot(np.exp(a - max_a), np.exp(b - max_b))\n np.log(C, out=C)\n # else:\n # np.log(C + 1e-300, out=C)\n\n C += max_a + max_b\n\n return C.transpose() if redAxis==1 else C\n\n\ndef logMax(a, b, redAxis=None):\n\n if redAxis==1:\n b = b.transpose()\n\n max_a = np.amax(a)\n max_b = np.amax(b)\n\n C = np.max(np.exp(a[:, :, None]-max_a) * np.exp(b[None, :, :]-max_b), axis=1)\n\n # if np.isfinite(C).all():\n np.log(C, out=C)\n # else:\n # np.log(C + 1e-300, out=C)\n\n C += max_a + max_b\n\n return C.transpose() if redAxis==1 else C\n\ndef logNormalize(a):\n\n denom = np.logaddexp.reduce(a, 1)\n return (a.transpose()- denom).transpose()\n\ndef logNormalizeTensor(a):\n\n denom = logSumExpTensor(a)\n if len(a.size())==2:\n denom = denom.view(-1, 1).expand(-1, a.size()[1])\n elif len(a.size())==3:\n denom = denom.view(a.size()[0], 1, 1).expand(-1, a.size()[1], a.size()[2])\n\n return (a-denom)\n\ndef computeF1(hyps, golds, prefix, labels_to_ix=None, baseline=False, write_results=False):\n \"\"\"\n hyps: List of dicts for predicted morphological tags\n golds: List of dicts for gold morphological tags\n \"\"\"\n\n f1_precision_scores = {}\n f1_precision_total = {}\n f1_recall_scores = {}\n f1_recall_total = {}\n f1_average = 0.0\n \n if baseline:\n hyps = [unfreeze_dict(h) for h in hyps]\n golds = [unfreeze_dict(t) for t in golds]\n\n # calculate precision\n for i, word_tags in enumerate(hyps, start=0):\n for k, v in word_tags.items():\n if v==\"NULL\":\n continue\n if k not in f1_precision_scores:\n f1_precision_scores[k] = 0\n f1_precision_total[k] = 0\n if k in golds[i]:\n if v==golds[i][k]:\n f1_precision_scores[k] += 1\n f1_precision_total[k] += 1\n \n f1_micro_precision = sum(f1_precision_scores.values())/sum(f1_precision_total.values())\n\n for k in f1_precision_scores.keys():\n f1_precision_scores[k] = f1_precision_scores[k]/f1_precision_total[k]\n \n # calculate recall\n for i, word_tags in enumerate(golds, start=0):\n for k, v in word_tags.items():\n if v==\"NULL\":\n continue\n if k not in f1_recall_scores:\n f1_recall_scores[k] = 0\n f1_recall_total[k] = 0\n if k in hyps[i]:\n if v==hyps[i][k]:\n f1_recall_scores[k] += 1\n f1_recall_total[k] += 1\n\n f1_micro_recall = sum(f1_recall_scores.values())/sum(f1_recall_total.values())\n\n f1_scores = {}\n for k in f1_recall_scores.keys():\n f1_recall_scores[k] = f1_recall_scores[k]/f1_recall_total[k]\n \n if f1_recall_scores[k]==0 or k not in f1_precision_scores:\n f1_scores[k] = 0\n else:\n f1_scores[k] = 2 * (f1_precision_scores[k] * f1_recall_scores[k]) / (f1_precision_scores[k] + f1_recall_scores[k])\n\n f1_average += f1_recall_total[k] * f1_scores[k]\n\n f1_average /= sum(f1_recall_total.values())\n f1_micro_score = 2 * (f1_micro_precision * f1_micro_recall) / (f1_micro_precision + f1_micro_recall)\n\n\n if write_results:\n print(\"Writing F1 scores...\")\n with open(prefix + '_results_f1.txt', 'ab') as file:\n file.write(pickle.dumps(f1_scores))\n file.write(\"\\nMacro-averaged F1 Score: \" + str(f1_average))\n file.write(\"\\nMicro-averaged F1 Score: \" + str(f1_micro_score))\n\n\n return f1_average, f1_micro_score\n\n\ndef getCorrectCount(golds, hyps):\n\n correct = 0\n\n for i, word_tags in enumerate(golds, start=0):\n allCorrect = True\n for k, v in word_tags.items():\n if k in hyps[i]:\n if v!=hyps[i][k]:\n allCorrect = False\n break\n\n if allCorrect==True:\n correct += 1\n\n return correct\n"
] | [
[
"numpy.set_printoptions",
"numpy.exp",
"numpy.logaddexp.reduce",
"torch.LongTensor",
"torch.exp",
"numpy.log",
"torch.autograd.Variable",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.tick_params",
"matplotlib.use",
"torch.max",
"matplotlib.pyplot.close",
"matplotlib.rc",
"matplotlib.pyplot.figure",
"numpy.amax",
"torch.log",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.ylabel",
"numpy.maximum"
]
] |
bwingert/ProDy | [
"7377a20b4a4841ec59dccaa93fa58e2ee0fe89bc"
] | [
"prody/utilities/catchall.py"
] | [
"\"\"\"This module defines miscellaneous utility functions that is public to users.\"\"\"\n\nimport numpy as np\nfrom numpy import unique, linalg, diag, sqrt, dot\n\nfrom Bio.Phylo.BaseTree import Tree, Clade\n\nfrom prody import PY3K\nfrom .misctools import addEnds, interpY, index, isListLike\nfrom .checkers import checkCoords\nfrom .logger import LOGGER\n\n\n__all__ = ['calcTree', 'clusterMatrix', 'showLines', 'showMatrix', \n 'reorderMatrix', 'findSubgroups', 'getCoords', \n 'getLinkage', 'getTreeFromLinkage', 'clusterSubfamilies']\n\nclass LinkageError(Exception):\n pass\n\ndef clusterSubfamilies(similarities, n_clusters=0, linkage='all', method='tsne', cutoff=0.0, **kwargs):\n \"\"\"Perform clustering based on members of the *ensemble* projected into lower a reduced\n dimension.\n \n :arg similarities: a matrix of similarities for each structure in the ensemble, such as\n RMSD-matrix, dynamics-based spectral overlap, sequence similarity\n :type similarities: :class:`~numpy.ndarray`\n\n :arg n_clusters: the number of clusters to generate. If **0**, will scan a range of \n number of clusters and return the best one based on highest\n silhouette score. Default is **0**.\n :type n_clusters: int\n\n :arg linkage: if **all**, will test all linkage types (ward, average, complete,\n single). Otherwise will use only the one(s) given as input. Default is\n **all**.\n :type linkage: str, list, tuple, :class:`~numpy.ndarray`\n\n :arg method: if set to **spectral**, will generate a Kirchoff matrix based on the \n cutoff value given and use that as input as clustering instead of\n the values themselves. Default is **tsne**.\n :type method: str\n\n :arg cutoff: only used if *method* is set to **spectral**. This value is used for \n generating the Kirchoff matrix to use for generating clusters when\n doing spectral clustering. Default is **0.0**.\n :type cutoff: float\n \"\"\"\n\n # Import necessary packages\n try:\n from sklearn.manifold import SpectralEmbedding\n from sklearn.cluster import AgglomerativeClustering\n from sklearn.metrics import silhouette_score\n from sklearn.manifold import TSNE\n except ImportError:\n raise ImportError('need sklearn module')\n '''\n try: \n import Bio \n except ImportError:\n raise ImportError('Phylo module could not be imported. '\n 'Reinstall ProDy or install Biopython '\n 'to solve the problem.')\n '''\n \n\n # Check inputs to make sure are of valid types/values\n if not isinstance(similarities, np.ndarray):\n raise TypeError('similarities should be a numpy ndarray')\n\n dim = similarities.shape\n if dim[0] != dim[1]:\n raise ValueError('similarities must be a square matrix')\n\n if n_clusters != 0:\n if not isinstance(n_clusters, int):\n raise TypeError('clusters must be an instance of int')\n if n_clusters < 1:\n raise ValueError('clusters must be a positive integer')\n elif n_clusters > similarities.shape[0]:\n raise ValueError('clusters can\\'t be longer than similarities matrix')\n nclusts = range(n_clusters,n_clusters+1)\n else:\n nclusts = range(2,10,1)\n\n if linkage != 'all':\n # Check if given input for linkage is list-like\n if isListLike(linkage):\n for val in linkage:\n if val.lower() not in ['ward', 'average', 'complete', 'single']:\n raise ValueError('linkage must be one or more of: \\'ward\\', \\'average\\', \\'complete\\', or \\'single\\'')\n if len(linkage) > 4:\n raise ValueError('linkage must be one or more of: \\'ward\\', \\'average\\', \\'complete\\', or \\'single\\'')\n linkages = [ x.lower() for x in linkage ]\n\n # If not, check if it is a valid string and method name\n else:\n if not isinstance(linkage, str):\n raise TypeError('linkage must be an instance of str or list-like of strs')\n\n if linkage not in ['ward', 'average', 'complete', 'single']:\n raise ValueError('linkage must one or more of: \\'ward\\', \\'average\\', \\'complete\\', or \\'single\\'')\n\n linkages = [linkage]\n else:\n linkages = ['ward', 'average', 'complete', 'single']\n\n if method != 'tsne':\n if not isinstance(method, str):\n raise TypeError('method must be an instance of str')\n if method != 'spectral':\n raise ValueError('method must be either \\'tsne\\' or \\'spectral\\'')\n\n if not isinstance(cutoff, float):\n raise TypeError('cutoff must be an instance of float')\n\n best_score = -1\n best_nclust = 0\n best_link = ''\n best_labels = []\n\n # Scan over range of clusters\n for x in nclusts:\n if method == 'tsne':\n embedding = TSNE(n_components=2)\n transform = embedding.fit_transform(similarities)\n\n else:\n kirchhoff = np.where(similarities > cutoff, 0, -1)\n embedding = SpectralEmbedding(n_components=2)\n transform = embedding.fit_transform(kirchhoff)\n\n for link in linkages:\n clustering = AgglomerativeClustering(linkage=link, n_clusters=x)\n clustering.fit(transform)\n\n silhouette_avg = silhouette_score(transform, clustering.labels_)\n \n if silhouette_avg > best_score:\n best_score = silhouette_avg\n best_nclust = x\n best_link = link\n best_labels = clustering.labels_\n\n\n return best_labels\n\ndef getCoords(data):\n\n try:\n data = (data._getCoords() if hasattr(data, '_getCoords') else\n data.getCoords())\n except AttributeError:\n try:\n checkCoords(data)\n except TypeError:\n raise TypeError('data must be a Numpy array or an object '\n 'with `getCoords` method')\n\n return data\n\ndef getLinkage(names, tree):\n \"\"\" Obtain the :func:`~scipy.cluster.hierarchy.linkage` matrix encoding \n ``tree``. \n \n :arg names: a list of names, the order determines the values in the \n linkage matrix\n :type names: list, :class:`~numpy.ndarray`\n\n :arg tree: tree to be converted\n :type tree: :class:`~Bio.Phylo.BaseTree.Tree`\n \"\"\"\n\n tree_terminals = tree.get_terminals()\n\n if len(tree_terminals) != len(names):\n raise ValueError('inconsistent number of terminals in tree and names')\n \n terminals = [None] * len(names)\n for clade in tree_terminals:\n i = index(names, clade.name)\n terminals[i] = clade\n\n n = len(terminals)\n nonterminals = [c for c in reversed(tree.get_nonterminals())]\n if len(nonterminals) != n-1:\n raise LinkageError('wrong number of terminal clades')\n\n Z = np.zeros((n-1, 4))\n\n root = tree.root\n\n def _indexOfClade(clade):\n if clade.is_terminal():\n i = index(terminals, clade)\n else:\n i = index(nonterminals, clade) + n\n return i\n\n def _height_of(clade):\n if clade.is_terminal():\n height = 0 \n else:\n height = max(_height_of(c) + c.branch_length for c in clade.clades)\n\n return height\n\n def _dfs(clade):\n if clade.is_terminal():\n return\n\n i = _indexOfClade(clade)\n clade_a = clade.clades[0]\n clade_b = clade.clades[1]\n\n a = _indexOfClade(clade_a)\n b = _indexOfClade(clade_b) \n\n l = min(a, b)\n r = max(a, b)\n\n Z[i-n, 0] = l\n Z[i-n, 1] = r\n Z[i-n, 2] = _height_of(clade) * 2.\n Z[i-n, 3] = clade.count_terminals()\n\n _dfs(clade_a)\n _dfs(clade_b)\n \n _dfs(root)\n\n return Z\n\ndef getTreeFromLinkage(names, linkage):\n \"\"\" Obtain the tree encoded by ``linkage``. \n \n :arg names: a list of names, the order should correspond to the values in \n linkage\n :type names: list, :class:`~numpy.ndarray`\n\n :arg linkage: linkage matrix\n :type linkage: :class:`~numpy.ndarray`\n \"\"\"\n try: \n import Bio \n except ImportError:\n raise ImportError('Phylo module could not be imported. '\n 'Reinstall ProDy or install Biopython '\n 'to solve the problem.')\n\n from Bio.Phylo.BaseTree import Tree, Clade\n \n if not isinstance(linkage, np.ndarray):\n raise TypeError('linkage must be a numpy.ndarray instance')\n\n if linkage.ndim != 2:\n raise LinkageError('linkage must be a 2-dimensional matrix')\n\n if linkage.shape[1] != 4:\n raise LinkageError('linkage must have exactly 4 columns')\n\n n_terms = len(names)\n if linkage.shape[0] != n_terms-1:\n raise LinkageError('linkage must have exactly len(names)-1 rows')\n \n clades = []\n heights = []\n for name in names:\n clade = Clade(None, name)\n clades.append(clade)\n heights.append(0.)\n\n for link in linkage:\n l = int(link[0])\n r = int(link[1])\n height = link[2]\n\n left = clades[l]\n right = clades[r]\n\n lh = heights[l]\n rh = heights[r]\n\n left.branch_length = height - lh\n right.branch_length = height - rh\n\n clade = Clade(None, None)\n clade.clades.append(left)\n clade.clades.append(right)\n\n clades.append(clade)\n heights.append(height)\n\n return Tree(clade)\n\ndef calcTree(names, distance_matrix, method='upgma', linkage=False):\n \"\"\" Given a distance matrix, it creates an returns a tree structure.\n\n :arg names: a list of names\n :type names: list, :class:`~numpy.ndarray`\n\n :arg distance_matrix: a square matrix with length of ensemble. If numbers does not match *names*\n it will raise an error\n :type distance_matrix: :class:`~numpy.ndarray`\n\n :arg method: method used for constructing the tree. Acceptable options are ``\"upgma\"``, ``\"nj\"``, \n or methods supported by :func:`~scipy.cluster.hierarchy.linkage` such as ``\"single\"``, \n ``\"average\"``, ``\"ward\"``, etc. Default is ``\"upgma\"``\n :type method: str\n\n :arg linkage: whether the linkage matrix is returned. Note that NJ trees do not support linkage\n :type linkage: bool\n \"\"\"\n try: \n import Bio \n except ImportError:\n raise ImportError('Phylo module could not be imported. '\n 'Reinstall ProDy or install Biopython '\n 'to solve the problem.')\n \n from .TreeConstruction import DistanceMatrix, DistanceTreeConstructor\n \n if len(names) != distance_matrix.shape[0] or len(names) != distance_matrix.shape[1]:\n raise ValueError(\"Mismatch between the sizes of matrix and names.\")\n \n method = method.lower().strip()\n\n if method in ['ward', 'single', 'average', 'weighted', 'centroid', 'median']:\n from scipy.cluster.hierarchy import linkage as hlinkage\n from scipy.spatial.distance import squareform\n \n Z = hlinkage(squareform(distance_matrix), method=method)\n tree = getTreeFromLinkage(names, Z)\n else:\n matrix = []\n k = 1\n Z = None\n for row in distance_matrix:\n matrix.append(list(row[:k]))\n k = k + 1\n \n if isinstance(names, np.ndarray):\n names = names.tolist()\n dm = DistanceMatrix(names, matrix)\n constructor = DistanceTreeConstructor()\n\n method = method.strip().lower()\n if method == 'nj':\n tree = constructor.nj(dm)\n elif method == 'upgma':\n tree = constructor.upgma(dm)\n if linkage:\n Z = getLinkage(names, tree)\n else:\n raise ValueError('Method can be only either \"nj\", \"upgma\" or '\n 'hierarchical clustering such as \"single\", \"average\", etc.')\n\n for node in tree.get_nonterminals():\n node.name = None\n\n if linkage:\n return tree, Z\n else:\n return tree\n\ndef writeTree(filename, tree, format_str='newick'):\n \"\"\" Write a tree to file using Biopython.\n\n :arg filename: name for output file\n :type filename: str\n\n :arg tree: a square matrix with length of ensemble. If numbers does not match *names*\n it will raise an error\n :type tree: :class:`~Bio.Phylo.BaseTree.Tree`\n\n :arg format_str: a string specifying the format for the tree\n :type format_str: str\n \"\"\"\n try: \n from Bio import Phylo\n except ImportError:\n raise ImportError('Phylo module could not be imported. '\n 'Reinstall ProDy or install Biopython '\n 'to solve the problem.')\n\n if not isinstance(filename, str):\n raise TypeError('filename should be a string')\n\n if not isinstance(tree, Phylo.BaseTree.Tree):\n raise TypeError('tree should be a Biopython.Phylo Tree object')\n\n if not isinstance(format_str, str):\n raise TypeError('format_str should be a string')\n\n Phylo.write(tree, filename, format_str)\n\n\ndef clusterMatrix(distance_matrix=None, similarity_matrix=None, labels=None, return_linkage=None, **kwargs):\n \"\"\"\n Cluster a distance matrix using scipy.cluster.hierarchy and \n return the sorted matrix, indices used for sorting, sorted labels (if **labels** are passed), \n and linkage matrix (if **return_linkage** is **True**). Set ``similarity=True`` for clustering a similarity matrix\n \n :arg distance_matrix: an N-by-N matrix containing some measure of distance \n such as 1. - seqid_matrix, rmsds, or distances in PCA space\n :type similarity_matrix: :class:`~numpy.ndarray`\n\n :arg similarity_matrix: an N-by-N matrix containing some measure of similarity \n such as sequence identity, mode-mode overlap, or spectral overlap\n :type similarity_matrix: :class:`~numpy.ndarray`\n \n :arg labels: labels for each matrix row that can be returned sorted\n :type labels: list\n\n :arg no_plot: if **True**, don't plot the dendrogram.\n default is **True**\n :type no_plot: bool\n \n :arg reversed: if set to **True**, then the sorting indices will be reversed.\n :type reversed: bool\n\n Other arguments for :func:`~scipy.hierarchy.linkage` and :func:`~scipy.hierarchy.dendrogram`\n can also be provided and will be taken as **kwargs**.\n \"\"\"\n\n import scipy.cluster.hierarchy as sch\n from scipy import spatial\n if similarity_matrix is None and distance_matrix is None:\n raise ValueError('Please provide a distance matrix or a similarity matrix')\n \n orientation = kwargs.pop('orientiation', 'right')\n reversed = kwargs.pop('reversed', False)\n no_plot = kwargs.pop('no_plot', True)\n\n if distance_matrix is None:\n matrix = similarity_matrix\n distance_matrix = 1. - similarity_matrix\n else:\n matrix = distance_matrix\n \n formatted_distance_matrix = spatial.distance.squareform(distance_matrix)\n linkage_matrix = sch.linkage(formatted_distance_matrix, **kwargs)\n sorting_dendrogram = sch.dendrogram(linkage_matrix, orientation=orientation, labels=labels, no_plot=no_plot)\n\n indices = sorting_dendrogram['leaves']\n sorted_labels = sorting_dendrogram['ivl']\n\n if reversed:\n indices = indices[::-1]\n sorted_labels = sorted_labels[::-1]\n \n sorted_matrix = matrix[indices, :]\n sorted_matrix = sorted_matrix[:, indices]\n \n return_vals = [sorted_matrix, indices]\n\n if labels is not None:\n return_vals.append(sorted_labels)\n if return_linkage:\n return_vals.append(linkage_matrix)\n return tuple(return_vals) # convert to tuple to avoid [pylint] E0632:Possible unbalanced tuple unpacking\n\ndef showLines(*args, **kwargs):\n \"\"\"\n Show 1-D data using :func:`~matplotlib.axes.Axes.plot`. \n \n :arg x: (optional) x coordinates. *x* can be an 1-D array or a 2-D matrix of \n column vectors.\n :type x: :class:`~numpy.ndarray`\n\n :arg y: data array. *y* can be an 1-D array or a 2-D matrix of \n column vectors.\n :type y: :class:`~numpy.ndarray`\n\n :arg dy: an array of variances of *y* which will be plotted as a \n band along *y*. It should have the same shape with *y*.\n :type dy: :class:`~numpy.ndarray`\n\n :arg lower: an array of lower bounds which will be plotted as a \n band along *y*. It should have the same shape with *y* and should be \n paired with *upper*.\n :type lower: :class:`~numpy.ndarray`\n\n :arg upper: an array of upper bounds which will be plotted as a \n band along *y*. It should have the same shape with *y* and should be \n paired with *lower*.\n :type upper: :class:`~numpy.ndarray`\n\n :arg alpha: the transparency of the band(s) for plotting *dy*.\n :type alpha: float\n\n :arg beta: the transparency of the band(s) for plotting *miny* and *maxy*.\n :type beta: float\n\n :arg ticklabels: user-defined tick labels for x-axis.\n :type ticklabels: list\n \"\"\"\n \n # note for developers: this function serves as a low-level \n # plotting function which provides basic utilities for other \n # plotting functions. Therefore showFigure is not handled \n # in this function as it should be already handled in the caller.\n\n ticklabels = kwargs.pop('ticklabels', None)\n dy = kwargs.pop('dy', None)\n miny = kwargs.pop('lower', None)\n maxy = kwargs.pop('upper', None)\n alpha = kwargs.pop('alpha', 0.5)\n beta = kwargs.pop('beta', 0.25)\n gap = kwargs.pop('gap', False)\n labels = kwargs.pop('label', None)\n\n from matplotlib import cm, ticker\n from matplotlib.pyplot import figure, gca, xlim\n\n ax = gca()\n lines = ax.plot(*args, **kwargs)\n\n polys = []\n \n for i, line in enumerate(lines):\n color = line.get_color()\n x, y = line.get_data()\n \n if gap:\n x_new, y_new = addEnds(x, y)\n line.set_data(x_new, y_new)\n else:\n x_new, y_new = x, y\n \n if labels is not None:\n if np.isscalar(labels):\n line.set_label(labels)\n else:\n try:\n line.set_label(labels[i])\n except IndexError:\n raise ValueError('The number of labels ({0}) and that of y ({1}) do not match.'\n .format(len(labels), len(line)))\n \n # the following function needs to be here so that line exists\n def sub_array(a, i, tag='a'):\n ndim = 0\n if a is not None:\n if np.isscalar(a[0]):\n ndim = 1 # a plain list (array)\n else:\n ndim = 2 # a nested list (array)\n else:\n return None\n\n if ndim == 1:\n _a = a\n else:\n try:\n _a = a[i]\n except IndexError:\n raise ValueError('The number of {2} ({0}) and that of y ({1}) do not match.'\n .format(len(miny), len(line), tag))\n\n if len(_a) != len(y):\n raise ValueError('The shapes of {2} ({0}) and y ({1}) do not match.'\n .format(len(_miny), len(y), tag))\n return _a\n\n if miny is not None and maxy is not None:\n _miny = sub_array(miny, i)\n _maxy = sub_array(maxy, i)\n\n if gap:\n _, _miny = addEnds(x, _miny)\n _, _maxy = addEnds(x, _maxy)\n \n poly = ax.fill_between(x_new, _miny, _maxy,\n alpha=beta, facecolor=color, edgecolor=None,\n linewidth=1, antialiased=True)\n polys.append(poly)\n\n if dy is not None:\n _dy = sub_array(dy, i)\n\n if gap:\n _, _dy = addEnds(x, _dy)\n \n poly = ax.fill_between(x_new, y_new-_dy, y_new+_dy,\n alpha=alpha, facecolor=color, edgecolor=None,\n linewidth=1, antialiased=True)\n polys.append(poly)\n\n ax.margins(x=0)\n if ticklabels is not None:\n if callable(ticklabels):\n ax.get_xaxis().set_major_formatter(ticker.FuncFormatter(ticklabels))\n else:\n ax.get_xaxis().set_major_formatter(ticker.IndexFormatter(ticklabels))\n \n ax.xaxis.set_major_locator(ticker.AutoLocator())\n ax.xaxis.set_minor_locator(ticker.AutoMinorLocator())\n\n return lines, polys\n\ndef showMatrix(matrix, x_array=None, y_array=None, **kwargs):\n \"\"\"Show a matrix using :meth:`~matplotlib.axes.Axes.imshow`. Curves on x- and y-axis can be added.\n\n :arg matrix: matrix to be displayed\n :type matrix: :class:`~numpy.ndarray`\n\n :arg x_array: data to be plotted above the matrix\n :type x_array: :class:`~numpy.ndarray`\n\n :arg y_array: data to be plotted on the left side of the matrix\n :type y_array: :class:`~numpy.ndarray`\n\n :arg percentile: a percentile threshold to remove outliers, i.e. only showing data within *p*-th \n to *100-p*-th percentile\n :type percentile: float\n\n :arg interactive: turn on or off the interactive options\n :type interactive: bool\n\n :arg xtickrotation: how much to rotate the xticklabels in degrees\n default is 0\n :type xtickrotation: float\n \"\"\"\n\n from matplotlib import ticker\n from matplotlib.gridspec import GridSpec\n from matplotlib.collections import LineCollection\n from matplotlib.pyplot import gca, sca, sci, colorbar, subplot\n\n from .drawtools import drawTree\n\n p = kwargs.pop('percentile', None)\n vmin = vmax = None\n if p is not None:\n vmin = np.percentile(matrix, p)\n vmax = np.percentile(matrix, 100-p)\n \n vmin = kwargs.pop('vmin', vmin)\n vmax = kwargs.pop('vmax', vmax)\n vcenter = kwargs.pop('vcenter', None)\n norm = kwargs.pop('norm', None)\n\n if vcenter is not None and norm is None:\n if PY3K:\n try:\n from matplotlib.colors import DivergingNorm\n except ImportError:\n from matplotlib.colors import TwoSlopeNorm as DivergingNorm\n\n norm = DivergingNorm(vmin=vmin, vcenter=0., vmax=vmax)\n else:\n LOGGER.warn('vcenter cannot be used in Python 2 so norm remains None')\n\n lw = kwargs.pop('linewidth', 1)\n \n W = H = kwargs.pop('ratio', 6)\n\n ticklabels = kwargs.pop('ticklabels', None)\n xticklabels = kwargs.pop('xticklabels', ticklabels)\n yticklabels = kwargs.pop('yticklabels', ticklabels)\n\n xtickrotation = kwargs.pop('xtickrotation', 0.)\n\n show_colorbar = kwargs.pop('colorbar', True)\n cb_extend = kwargs.pop('cb_extend', 'neither')\n allticks = kwargs.pop('allticks', False) # this argument is temporary and will be replaced by better implementation\n interactive = kwargs.pop('interactive', True)\n\n cmap = kwargs.pop('cmap', 'jet')\n origin = kwargs.pop('origin', 'lower')\n\n try: \n from Bio import Phylo\n except ImportError:\n raise ImportError('Phylo module could not be imported. '\n 'Reinstall ProDy or install Biopython '\n 'to solve the problem.')\n tree_mode_y = isinstance(y_array, Phylo.BaseTree.Tree)\n tree_mode_x = isinstance(x_array, Phylo.BaseTree.Tree)\n\n if x_array is not None and y_array is not None:\n nrow = 2; ncol = 2\n i = 1; j = 1\n width_ratios = [1, W]\n height_ratios = [1, H]\n aspect = 'auto'\n elif x_array is not None and y_array is None:\n nrow = 2; ncol = 1\n i = 1; j = 0\n width_ratios = [W]\n height_ratios = [1, H]\n aspect = 'auto'\n elif x_array is None and y_array is not None:\n nrow = 1; ncol = 2\n i = 0; j = 1\n width_ratios = [1, W]\n height_ratios = [H]\n aspect = 'auto'\n else:\n nrow = 1; ncol = 1\n i = 0; j = 0\n width_ratios = [W]\n height_ratios = [H]\n aspect = kwargs.pop('aspect', None)\n\n main_index = (i, j)\n upper_index = (i-1, j)\n left_index = (i, j-1)\n\n complex_layout = nrow > 1 or ncol > 1\n\n ax1 = ax2 = ax3 = None\n\n if complex_layout:\n gs = GridSpec(nrow, ncol, width_ratios=width_ratios, \n height_ratios=height_ratios, hspace=0., wspace=0.)\n\n ## draw matrix\n if complex_layout:\n ax3 = subplot(gs[main_index])\n else:\n ax3 = gca()\n \n im = ax3.imshow(matrix, aspect=aspect, vmin=vmin, vmax=vmax, \n norm=norm, cmap=cmap, origin=origin, **kwargs)\n \n #ax3.set_xlim([-0.5, matrix.shape[0]+0.5])\n #ax3.set_ylim([-0.5, matrix.shape[1]+0.5])\n\n if xticklabels is not None:\n ax3.xaxis.set_major_formatter(ticker.IndexFormatter(xticklabels))\n if yticklabels is not None and ncol == 1:\n ax3.yaxis.set_major_formatter(ticker.IndexFormatter(yticklabels))\n\n if allticks:\n ax3.xaxis.set_major_locator(ticker.IndexLocator(offset=0.5, base=1.))\n ax3.yaxis.set_major_locator(ticker.IndexLocator(offset=0.5, base=1.))\n else:\n locator = ticker.AutoLocator()\n locator.set_params(integer=True)\n minor_locator = ticker.AutoMinorLocator()\n\n ax3.xaxis.set_major_locator(locator)\n ax3.xaxis.set_minor_locator(minor_locator)\n\n locator = ticker.AutoLocator()\n locator.set_params(integer=True)\n minor_locator = ticker.AutoMinorLocator()\n \n ax3.yaxis.set_major_locator(locator)\n ax3.yaxis.set_minor_locator(minor_locator)\n\n if ncol > 1:\n ax3.yaxis.set_major_formatter(ticker.NullFormatter())\n \n ## draw x_ and y_array\n lines = []\n\n if nrow > 1:\n ax1 = subplot(gs[upper_index])\n\n if tree_mode_x:\n Y, X = drawTree(x_array, label_func=None, orientation='vertical', \n inverted=True)\n miny = min(Y.values())\n maxy = max(Y.values())\n\n minx = min(X.values())\n maxx = max(X.values())\n\n ax1.set_xlim(minx-.5, maxx+.5)\n ax1.set_ylim(miny, 1.05*maxy)\n else:\n ax1.set_xticklabels([])\n \n y = x_array\n xp, yp = interpY(y)\n points = np.array([xp, yp]).T.reshape(-1, 1, 2)\n segments = np.concatenate([points[:-1], points[1:]], axis=1)\n lcy = LineCollection(segments, array=yp, linewidths=lw, cmap=cmap)\n lines.append(lcy)\n ax1.add_collection(lcy)\n\n ax1.set_xlim(xp.min()-.5, xp.max()+.5)\n ax1.set_ylim(yp.min(), yp.max())\n\n if ax3.xaxis_inverted():\n ax2.invert_xaxis()\n\n ax1.axis('off')\n\n if ncol > 1:\n ax2 = subplot(gs[left_index])\n \n if tree_mode_y:\n X, Y = drawTree(y_array, label_func=None, inverted=True)\n miny = min(Y.values())\n maxy = max(Y.values())\n\n minx = min(X.values())\n maxx = max(X.values())\n\n ax2.set_ylim(miny-.5, maxy+.5)\n ax2.set_xlim(minx, 1.05*maxx)\n else:\n ax2.set_xticklabels([])\n \n y = y_array\n xp, yp = interpY(y)\n points = np.array([yp, xp]).T.reshape(-1, 1, 2)\n segments = np.concatenate([points[:-1], points[1:]], axis=1)\n lcx = LineCollection(segments, array=yp, linewidths=lw, cmap=cmap)\n lines.append(lcx)\n ax2.add_collection(lcx)\n ax2.set_xlim(yp.min(), yp.max())\n ax2.set_ylim(xp.min()-.5, xp.max()+.5)\n \n ax2.invert_xaxis()\n\n if ax3.yaxis_inverted():\n ax2.invert_yaxis()\n\n ax2.axis('off')\n\n ## draw colorbar\n sca(ax3)\n cb = None\n if show_colorbar:\n if nrow > 1:\n axes = [ax1, ax2, ax3]\n while None in axes:\n axes.remove(None)\n s = H / (H + 1.)\n cb = colorbar(mappable=im, ax=axes, anchor=(0, 0), shrink=s, extend=cb_extend)\n else:\n cb = colorbar(mappable=im, extend=cb_extend)\n\n sca(ax3)\n sci(im)\n\n if interactive:\n from prody.utilities import ImageCursor\n from matplotlib.pyplot import connect\n cursor = ImageCursor(ax3, im)\n connect('button_press_event', cursor.onClick)\n\n ax3.tick_params(axis='x', rotation=xtickrotation)\n\n return im, lines, cb\n\ndef reorderMatrix(names, matrix, tree, axis=None):\n \"\"\"\n Reorder a matrix based on a tree and return the reordered matrix \n and indices for reordering other things.\n\n :arg names: a list of names associated with the rows of the matrix\n These names must match the ones used to generate the tree\n :type names: list\n\n :arg matrix: any square matrix\n :type matrix: :class:`~numpy.ndarray`\n\n :arg tree: any tree from :func:`calcTree`\n :type tree: :class:`~Bio.Phylo.BaseTree.Tree`\n\n :arg axis: along which axis the matrix should be reordered. \n Default is **None** which reorder along all the axes\n :type axis: int\n \"\"\"\n\n try:\n from Bio import Phylo\n except ImportError:\n raise ImportError('Phylo module could not be imported. '\n 'Reinstall ProDy or install Biopython '\n 'to solve the problem.')\n\n try:\n if matrix.ndim != 2:\n raise ValueError('matrix should be a 2D matrix.')\n except AttributeError:\n raise TypeError('matrix should be a numpy array.')\n\n if np.shape(matrix)[0] != np.shape(matrix)[1]:\n raise ValueError('matrix should be a square matrix')\n \n names = np.asarray(names)\n\n if np.isscalar(names):\n raise TypeError('names should be list-like')\n \n if not len(names):\n raise TypeError('names is empty')\n\n if not isinstance(tree, Phylo.BaseTree.Tree):\n raise TypeError('tree should be a BioPython Tree')\n\n if len(names) != len(matrix):\n raise ValueError('names should have entries for each matrix row/column')\n \n terminals = tree.get_terminals()\n if len(names) != len(terminals):\n raise ValueError('names should have entries for each tree terminal')\n\n if len(terminals) != len(matrix):\n raise ValueError('matrix should have a row for each tree terminal')\n\n indices = []\n for terminal in terminals:\n name = terminal.name\n locs = np.where(names == name)[0]\n if not len(locs):\n raise ValueError('inconsistent names and tree: %s not in names'%name)\n\n if len(locs) > 1:\n raise ValueError('inconsistent names and tree: duplicate name %s in names'%name)\n indices.append(locs[0])\n\n # rmatrix = matrix[:, indices]\n # rmatrix = rmatrix[indices, :]\n\n if axis is not None:\n I = [np.arange(s) for s in matrix.shape] \n axes = [axis] if np.isscalar(axis) else axis\n for ax in axes:\n I[ax] = indices\n else:\n I = [indices] * matrix.ndim\n \n rmatrix = matrix[np.ix_(*I)]\n \n return rmatrix, indices\n\ndef findSubgroups(tree, c, method='naive', **kwargs):\n \"\"\"\n Divide a tree into subgroups using a criterion and a cutoff.\n Returns a list of lists with labels divided into subgroups.\n \"\"\"\n\n method = method.lower().strip()\n terminals = tree.get_terminals()\n names = [clade.name for clade in terminals]\n Z = None\n\n if method != 'naive':\n try:\n Z = getLinkage(names, tree)\n except LinkageError:\n print('Failed to build linkage; fall back to naive criterion')\n method = 'naive'\n \n if method == 'naive':\n subgroups = [[names[0]]]\n for i in range(len(terminals)-1):\n curr_clade = terminals[i]\n next_clade = terminals[i + 1]\n d = tree.distance(curr_clade, next_clade)\n if d > c:\n subgroups.append([])\n subgroups[-1].append(next_clade.name)\n else:\n from scipy.cluster.hierarchy import fcluster\n \n T = fcluster(Z, c, criterion=method, **kwargs)\n labels = np.unique(T)\n subgroups = [[] for _ in range(len(labels))]\n\n for i, t in enumerate(T):\n subgroups[t-1].append(names[i])\n\n return subgroups\n"
] | [
[
"matplotlib.pyplot.connect",
"scipy.cluster.hierarchy.fcluster",
"matplotlib.ticker.IndexFormatter",
"numpy.where",
"matplotlib.ticker.IndexLocator",
"matplotlib.ticker.FuncFormatter",
"numpy.concatenate",
"matplotlib.pyplot.colorbar",
"sklearn.cluster.AgglomerativeClustering",
"matplotlib.ticker.AutoMinorLocator",
"numpy.arange",
"matplotlib.pyplot.sci",
"matplotlib.pyplot.gca",
"sklearn.manifold.SpectralEmbedding",
"matplotlib.pyplot.subplot",
"scipy.cluster.hierarchy.dendrogram",
"scipy.cluster.hierarchy.linkage",
"numpy.array",
"numpy.zeros",
"numpy.percentile",
"matplotlib.pyplot.sca",
"scipy.spatial.distance.squareform",
"sklearn.manifold.TSNE",
"numpy.shape",
"numpy.ix_",
"matplotlib.collections.LineCollection",
"numpy.isscalar",
"matplotlib.ticker.NullFormatter",
"matplotlib.gridspec.GridSpec",
"numpy.asarray",
"matplotlib.ticker.AutoLocator",
"sklearn.metrics.silhouette_score",
"matplotlib.colors.TwoSlopeNorm",
"numpy.unique"
]
] |
ZHANG-CAIQI/COMP1001 | [
"abfad8101b4b58697dfbc8599eebf466beebb9ec"
] | [
"Assessments 1-8/Ass8/Q2_b_1.py"
] | [
"import matplotlib.pyplot as plt\r\nimport numpy as np\r\n\r\ndef stockUp(priceFile):\r\n\r\n # read the file\r\n infile = open(priceFile, \"r\")\r\n date = []\r\n stock = []\r\n\r\n # store only the dates and closing price\r\n day = 1\r\n firstLine = True\r\n for line in infile:\r\n if firstLine:\r\n firstLine = False\r\n else:\r\n count_item = 0\r\n for item in line.split(\",\"):\r\n if count_item == 0:\r\n date.append(day)\r\n elif count_item == 4:\r\n stock.append(float(item))\r\n count_item += 1\r\n day += 1\r\n\r\n infile.close()\r\n\r\n # Compute the up periods\r\n up = len(date)*[0]\r\n for k in range(1,len(stock)): # skip the heading\r\n i = k # i = k = 1\r\n while ((i>0) and float(stock[k])>=float(stock[i])):\r\n up[k] += 1\r\n i -= 1\r\n\r\n\r\n fig, ax1 = plt.subplots()\r\n\r\n color = 'tab:red'\r\n ax1.set_xlabel('Days started from 11/13/2017 and end on 11/12/2018')\r\n ax1.set_ylabel('Stock prices', color=color)\r\n ax1.plot(date, stock, color=color)\r\n ax1.tick_params(axis='y', labelcolor=color)\r\n\r\n ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis\r\n\r\n color = 'tab:blue'\r\n ax2.set_ylabel('Up periods', color=color) # we already handled the x-label with ax1\r\n ax2.plot(date, up, color=color)\r\n ax2.tick_params(axis='y', labelcolor=color)\r\n\r\n fig.tight_layout() # otherwise the right y-label is slightly clipped\r\n plt.show()\r\n\r\n return\r\n\r\n\"\"\"\r\n plt.plot(date, up, marker='x')\r\n plt.plot(date, stock, marker='o')\r\n plt.title('The up periods for 11/13/2017-11/12/2018')\r\n plt.xlabel('Days started from 11/13/2017 and end on 11/12/2018')\r\n plt.ylabel('The up periods of GOOGL at closing')\r\n plt.show()\r\n\"\"\" \r\n\r\n\r\nstockUp(\"GOOGL.csv\")\r\n\r\n"
] | [
[
"matplotlib.pyplot.show",
"matplotlib.pyplot.subplots"
]
] |
steffi7574/lbann | [
"665797a112dc96d15bd1d958de61f48bf5d3d21f"
] | [
"bamboo/unit_tests/test_unit_layer_gather.py"
] | [
"import functools\nimport operator\nimport os\nimport os.path\nimport sys\nimport numpy as np\n\n# Bamboo utilities\ncurrent_file = os.path.realpath(__file__)\ncurrent_dir = os.path.dirname(current_file)\nsys.path.insert(0, os.path.join(os.path.dirname(current_dir), 'common_python'))\nimport tools\n\n# ==============================================\n# Objects for Python data reader\n# ==============================================\n# Note: The Python data reader imports this file as a module and calls\n# the functions below to ingest data.\n\n# Data\ninput_size = 23\noutput_size = 15\nseed = 202101280\n\n# Sample access functions\ndef get_sample(index):\n np.random.seed(seed+index)\n values = [np.random.normal() for _ in range(input_size)]\n indices = [\n np.random.uniform(-1, input_size+1)\n for _ in range(output_size)\n ]\n return values + indices\ndef num_samples():\n return 25\ndef sample_dims():\n return (input_size+output_size,)\n\n# ==============================================\n# Setup LBANN experiment\n# ==============================================\n\ndef setup_experiment(lbann):\n \"\"\"Construct LBANN experiment.\n\n Args:\n lbann (module): Module for LBANN Python frontend\n\n \"\"\"\n mini_batch_size = num_samples() // 2\n trainer = lbann.Trainer(mini_batch_size)\n model = construct_model(lbann)\n data_reader = construct_data_reader(lbann)\n optimizer = lbann.NoOptimizer()\n return trainer, model, data_reader, optimizer\n\ndef construct_model(lbann):\n \"\"\"Construct LBANN model.\n\n Args:\n lbann (module): Module for LBANN Python frontend\n\n \"\"\"\n\n # Input data\n # Note: Sum with a weights layer so that gradient checking will\n # verify that error signals are correct.\n x = lbann.Identity(lbann.Input())\n x_slice = lbann.Slice(\n x,\n slice_points=tools.str_list([0,input_size,input_size+output_size]),\n )\n x0_weights = lbann.Weights(\n optimizer=lbann.SGD(),\n initializer=lbann.ConstantInitializer(value=0.0),\n name='input_weights',\n )\n x0 = lbann.Sum(\n lbann.Identity(x_slice),\n lbann.WeightsLayer(weights=x0_weights, dims=tools.str_list(input_size)),\n )\n x1 = lbann.Identity(x_slice)\n\n # Apply gather\n y0 = lbann.Gather(x0, x1)\n y1 = lbann.Concatenation([\n lbann.Constant(value=i+1, num_neurons='1')\n for i in range(output_size)\n ])\n y = lbann.Multiply(y0, y1)\n z = lbann.L2Norm2(y)\n\n # Objects for LBANN model\n layers = list(lbann.traverse_layer_graph(x))\n metric = lbann.Metric(z, name='obj')\n obj = lbann.ObjectiveFunction(z)\n callbacks = []\n\n # Compute expected metric value\n vals = []\n for i in range(num_samples()):\n x = get_sample(i)\n x0 = x[:input_size]\n x1 = x[input_size:]\n y0 = np.zeros(output_size)\n for i in range(output_size):\n if 0 <= x1[i] < input_size:\n y0[i] = x0[int(x1[i])]\n z = 0\n for i in range(output_size):\n z += ((i+1)*y0[i]) ** 2\n vals.append(z)\n val = np.mean(vals)\n tol = 8 * val * np.finfo(np.float32).eps\n callbacks.append(lbann.CallbackCheckMetric(\n metric=metric.name,\n lower_bound=val-tol,\n upper_bound=val+tol,\n error_on_failure=True,\n execution_modes='test'))\n\n # Gradient checking\n callbacks.append(lbann.CallbackCheckGradients(error_on_failure=True))\n\n # Construct model\n num_epochs = 0\n return lbann.Model(num_epochs,\n layers=layers,\n objective_function=obj,\n metrics=[metric],\n callbacks=callbacks)\n\ndef construct_data_reader(lbann):\n \"\"\"Construct Protobuf message for Python data reader.\n\n The Python data reader will import the current Python file to\n access the sample access functions.\n\n Args:\n lbann (module): Module for LBANN Python frontend\n\n \"\"\"\n\n # Note: The training data reader should be removed when\n # https://github.com/LLNL/lbann/issues/1098 is resolved.\n message = lbann.reader_pb2.DataReader()\n message.reader.extend([\n tools.create_python_data_reader(\n lbann,\n current_file,\n 'get_sample',\n 'num_samples',\n 'sample_dims',\n 'train'\n )\n ])\n message.reader.extend([\n tools.create_python_data_reader(\n lbann,\n current_file,\n 'get_sample',\n 'num_samples',\n 'sample_dims',\n 'test'\n )\n ])\n return message\n\n# ==============================================\n# Setup PyTest\n# ==============================================\n\n# Create test functions that can interact with PyTest\nfor _test_func in tools.create_tests(setup_experiment, __file__):\n globals()[_test_func.__name__] = _test_func\n"
] | [
[
"numpy.random.normal",
"numpy.zeros",
"numpy.random.seed",
"numpy.mean",
"numpy.finfo",
"numpy.random.uniform"
]
] |
bigvideoresearch/SCC | [
"f26cdb6aaf248b5112812dbdac1f1b5086aebccc"
] | [
"datasets/imagename_dataset.py"
] | [
"from runner_master import runner\nimport os\nimport io\nimport torch\nimport logging\nfrom PIL import Image, ImageFile\nfrom runner_master.runner.data import datasets\n# to fix \"OSError: image file is truncated\"\nImageFile.LOAD_TRUNCATED_IMAGES = True\n\nclass ImagenameDataset(datasets.ImglistDatasetV2):\n\n def getitem(self, index):\n line = self.imglist[index].strip('\\n')\n tokens = line.split(' ', maxsplit=1)\n #if len(tokens) != 2:\n # raise RuntimeError('split tokens < 2')\n\n image_name, extra_str = tokens[0], tokens[1]\n if self.root != '' and image_name.startswith('/'):\n raise RuntimeError('root not empty but image_name starts with \"/\"')\n path = os.path.join(self.root, image_name)\n sample = dict()\n sample['image_name'] = image_name\n try:\n if not self.dummy_read:\n filebytes = self.reader(path)\n buff = io.BytesIO(filebytes)\n if self.dummy_size is not None:\n sample['data'] = torch.rand(self.dummy_size)\n else:\n image = Image.open(buff)\n sample['data'] = self.transform_image(image)\n for key, value in self.transform_extra(extra_str).items():\n sample[key] = value\n except Exception as e:\n logging.error('[{}] broken'.format(path))\n raise e\n return sample\n\nrunner.patch_dataset('ImagenameDataset', ImagenameDataset)\n"
] | [
[
"torch.rand"
]
] |
hlzhang109/OpenPrompt | [
"8a1ec1ceac3805a11b09dda9b96ad7406d222f26",
"8a1ec1ceac3805a11b09dda9b96ad7406d222f26"
] | [
"openprompt/prompts/one2one_verbalizer.py",
"openprompt/prompt_base.py"
] | [
"import json\nfrom transformers.tokenization_utils import PreTrainedTokenizer\nfrom yacs.config import CfgNode\nfrom openprompt.data_utils.data_utils import InputFeatures\nimport re\nfrom openprompt import Verbalizer\nfrom typing import *\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom openprompt.utils.logging import logger\n\n\n\nclass One2oneVerbalizer(Verbalizer):\n r\"\"\"\n The basic manually defined verbalizer class, this class is inherited from the :obj:`Verbalizer` class.\n This class restrict the use of label words to one words per label. For a verbalzer with less constraints,\n please use Basic ManualVerbalizer.\n\n Args: \n tokenizer (:obj:`PreTrainedTokenizer`): The tokenizer of the current pre-trained model to point out the vocabulary.\n classes (:obj:`classes`): The classes (or labels) of the current task.\n num_classes (:obj:`int`): Optional. The number of classes of the verbalizer. Only one of `classes` and `num_classes` should be used.\n label_words (:obj:`Union[Sequence[str], Mapping[str, str]]`, optional): The label words that are projected by the labels.\n prefix (:obj:`str`, optional): The prefix string of the verbalizer. (used in PLMs like RoBERTa, which is sensitive to prefix space)\n multi_token_handler (:obj:`str`, optional): The handling strategy for multiple tokens produced by the tokenizer.\n \"\"\"\n def __init__(self, \n tokenizer: PreTrainedTokenizer,\n num_classes: Optional[int] = None,\n classes: Optional[List] = None,\n label_words: Optional[Union[Sequence[str], Mapping[str, str]]] = None,\n prefix: Optional[str] = \" \",\n multi_token_handler: Optional[str] = \"first\",\n ):\n super().__init__(tokenizer=tokenizer, num_classes=num_classes, classes=classes)\n self.prefix = prefix\n self.multi_token_handler = multi_token_handler\n self.label_words = label_words\n\n def on_label_words_set(self):\n super().on_label_words_set()\n self.label_words = self.add_prefix(self.label_words, self.prefix)\n self.generate_parameters()\n \n @staticmethod\n def add_prefix(label_words, prefix):\n r\"\"\"Add prefix to label words. For example, if a label words is in the middle of a template,\n the prefix should be ``' '``.\n\n Args:\n label_words (:obj:`Union[Sequence[str], Mapping[str, str]]`, optional): The label words that are projected by the labels.\n prefix (:obj:`str`, optional): The prefix string of the verbalizer.\n \n Returns:\n :obj:`Sequence[str]`: New label words with prefix.\n \"\"\"\n new_label_words = []\n if isinstance(label_words[0], list):\n assert max([len(w) for w in label_words]) == 1, \"Providing multiple label words, you should use other verbalizers instead.\"\n label_words = [w[0] for w in label_words] \n\n for word in label_words:\n if word.startswith(\"<!>\"):\n new_label_words.append(word.split(\"<!>\")[1])\n else:\n new_label_words.append(prefix + word)\n\n return new_label_words\n \n def generate_parameters(self) -> List:\n r\"\"\"In basic manual template, the parameters are generated from label words directly.\n In this implementation, the label_words should not be tokenized into more than one token. \n \"\"\"\n words_ids = []\n for word in self.label_words:\n word_ids = self.tokenizer.encode(word, add_special_tokens=False)\n if len(word_ids) > 1:\n logger.warning(\"Word {} is split into multiple tokens: {}. \\\n If this is not what you expect, try using another word for this verbalizer\" \\\n .format(word, self.tokenizer.convert_ids_to_tokens(word_ids)))\n words_ids.append(word_ids)\n \n \n max_len = max([len(ids) for ids in words_ids])\n words_ids_mask = [[1]*len(ids) + [0]*(max_len-len(ids)) for ids in words_ids]\n words_ids = [ids+[0]*(max_len-len(ids)) for ids in words_ids]\n \n words_ids_tensor = torch.tensor(words_ids)\n words_ids_mask = torch.tensor(words_ids_mask)\n self.label_words_ids = nn.Parameter(words_ids_tensor, requires_grad=False)\n self.label_words_mask = nn.Parameter(words_ids_mask, requires_grad=False)\n\n def project(self,\n logits: torch.Tensor,\n **kwargs,\n ) -> torch.Tensor:\n r\"\"\"\n Project the labels, the return value is the normalized (sum to 1) probs of label words. \n \n Args:\n logits (:obj:`torch.Tensor`): The orginal logits of label words.\n \n Returns:\n :obj:`torch.Tensor`: The normalized logits of label words\n \"\"\"\n label_words_logits = logits[:, self.label_words_ids]\n label_words_logits = self.handle_multi_token(label_words_logits, self.label_words_mask)\n return label_words_logits\n\n def process_logits(self, logits: torch.Tensor, **kwargs):\n r\"\"\"A whole framework to process the original logits over the vocabulary, which contains four steps: \n (1) Project the logits into logits of label words\n (2) Normalize over all label words\n (3) Calibrate (optional)\n Args:\n logits (:obj:`torch.Tensor`): The orginal logits.\n \n Returns:\n (:obj:`torch.Tensor`): The final processed logits over the label words set.\n \"\"\"\n # project\n label_words_logits = self.project(logits, **kwargs) #Output: (batch_size, num_classes) or (batch_size, num_classes, num_label_words_per_label)\n\n # normalize\n label_words_probs = self.normalize(label_words_logits)\n\n # calibrate\n if hasattr(self, \"_calibrate_logits\") and self._calibrate_logits is not None:\n label_words_probs = self.calibrate(label_words_probs=label_words_probs)\n\n # convert to logits\n label_words_logits = torch.log(label_words_probs+1e-15)\n return label_words_logits\n \n def normalize(self, logits: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Given logits regarding the entire vocabulary, return the probs over the label words set.\n \n Args:\n logits (:obj:`Tensor`): The logits over the entire vocabulary.\n\n Returns:\n :obj:`Tensor`: The logits over the label words set.\n \n \"\"\"\n batch_size = logits.shape[0]\n return F.softmax(logits.reshape(batch_size, -1), dim=-1).reshape(*logits.shape)\n\n\n def calibrate(self, label_words_probs: torch.Tensor, **kwargs) -> torch.Tensor:\n r\"\"\"\n \n Args:\n label_words_probs (:obj:`torch.Tensor`): The probability distribution of the label words with the shape of [``batch_size``, ``num_classes``, ``num_label_words_per_class``]\n \n Returns:\n :obj:`torch.Tensor`: The calibrated probability of label words.\n \"\"\"\n shape = label_words_probs.shape\n assert self._calibrate_logits.dim() == 1, \"self._calibrate_logits are not 1-d tensor\"\n calibrate_label_words_probs = self.normalize(self.project(self._calibrate_logits.unsqueeze(0), **kwargs))\n assert calibrate_label_words_probs.shape[1:] == label_words_probs.shape[1:] \\\n and calibrate_label_words_probs.shape[0]==1, \"shape not match\"\n label_words_probs /= (calibrate_label_words_probs+1e-15)\n # normalize # TODO Test the performance\n norm = label_words_probs.reshape(shape[0], -1).sum(dim=-1,keepdim=True) # TODO Test the performance of detaching()\n label_words_probs /= norm\n return label_words_probs\n \n\n \n\n\n \n \n",
"from abc import abstractmethod\nimport json\nfrom openprompt.config import convert_cfg_to_dict\n\nfrom transformers.utils.dummy_pt_objects import PreTrainedModel\nfrom openprompt.utils.utils import signature\n\nfrom yacs.config import CfgNode\nfrom openprompt.data_utils.data_utils import InputFeatures\nimport torch\nimport torch.nn as nn\nfrom openprompt.data_utils import InputExample\nfrom typing import *\nfrom transformers.tokenization_utils import PreTrainedTokenizer\n\nfrom openprompt.utils.logging import logger\nimport numpy as np\nimport torch.nn.functional as F\n\n\n\n\nclass Template(nn.Module):\n r'''\n Base class for all the templates. \n Most of methods are abstract, with some expections to hold the common methods for all template, such as ``loss_ids``, ``save``, ``load``.\n\n Args: \n tokenizer (:obj:`PreTrainedTokenizer`): A tokenizer to appoint the vocabulary and the tokenization strategy.\n mask_token (:obj:`str`): The special token that is masked and need to be predicted by the model.\n placeholder_mapping (:obj:`dict`): A place holder to represent the original input text. \n '''\n\n registered_inputflag_names = [\"loss_ids\", \"shortenable_ids\"]\n\n def __init__(self, \n tokenizer: PreTrainedTokenizer,\n mask_token: str = '<mask>',\n placeholder_mapping: dict = {'<text_a>':'text_a','<text_b>':'text_b'},\n ):\n super().__init__()\n self.mask_token = mask_token\n self.tokenizer = tokenizer\n self.placeholder_mapping = placeholder_mapping\n self._in_on_text_set = False\n\n def get_default_loss_ids(self):\n r'''Get the loss indices for the template using mask.\n E.g. when self.text is ``['<text_a>', 'it', 'is', '<mask>', '.']``, output is ``[0, 0, 0, 1, 0]``.\n\n Returns:\n :obj:`List[int]`: A list of integers in the range [0, 1]:\n \n - 1 for a masked tokens.\n - 0 for a sequence tokens.\n '''\n idx = [\n 1 if token==self.mask_token\n else 0\n for token in self.text\n ]\n return idx\n\n def get_default_shortenable_ids(self) -> List[int]:\n r\"\"\"Every template needs shortenable_ids, denoting which part of the template can be trucate to fit\n the language model's ``max_seq_length``. Default: the input text is shortenable, while the template text and other\n special tokens are not shortenable. As far as we are concerned, almost every template will use this default setting. \n e.g. when self.text is ``['<text_a>', '<meta:word>', 'is', '<mask>', '.']``, output is ``[1, 0, 0, 0, 0]``\n \n Returns:\n :obj:`List[int]`: A list of integers in the range ``[0, 1]``:\n\n - 1 for the input tokens.\n - 0 for the template sequence tokens.\n \"\"\"\n idx = [\n 1 if any([placeholder in token for placeholder in self.placeholder_mapping.keys()])\n else 0\n for token in self.text\n ]\n return idx\n\n def get_default_new_token_ids(self) -> List[int]:\n r'''\n Sometimes tokens in the template are not from the vocabulary, \n but a sequence of newly iniliazed tokens (ones may say, soft-encoding).\n In this case, you need to implement this function.\n\n Raises:\n NotImplementedError: if needed, add ``new_token_ids`` into ``registered_inputflag_names`` attribute of Template class and implement this method.\n '''\n raise NotImplementedError\n\n def get_default_soft_token_ids(self) -> List[int]:\n r'''\n This function identifies which tokens are soft tokens.\n\n Raises:\n NotImplementedError: if needed, add ``soft_token_ids`` into ``registered_inputflag_names`` attribute of Template class and implement this method.\n '''\n raise NotImplementedError\n \n # @abstractmethod\n def wrap_one_example(self, \n example: InputExample) -> List[Dict]:\n r'''Given an input example which contains input text, which can be referenced\n by self.template.placeholder_mapping 's value. \n This function process the example into a list of dict,\n Each dict functions as a group, which has the sample properties, such as\n whether it's shortenable, whether it's the masked position, whether it's soft token, etc.\n Since a text will be tokenized in the subsequent processing procedure,\n these attributes are broadcasted along the tokenized sentence.\n \n Args:\n example (:obj:`Object`): An :py:class:`~openprompt.data_utils.data_utils.InputExample` object, which should have attributes that are able to be filled in the template.\n \n Returns:\n :obj:`List[Dict]`\n '''\n \n not_empty_keys = example.keys()\n if self.text is None:\n raise ValueError(\"template text has not been initialized\")\n if isinstance(example, InputExample):\n text = self.text.copy()\n for placeholder_token in self.placeholder_mapping:\n for i in range(len(text)):\n text[i] = text[i].replace(placeholder_token, getattr(example, self.placeholder_mapping[placeholder_token]))\n not_empty_keys.remove(self.placeholder_mapping[placeholder_token]) # this key has been processed, remove\n for key, value in example.meta.items():\n for i in range(len(text)):\n text[i] = text[i].replace(\"<meta:\"+key+\">\", value)\n not_empty_keys.remove('meta') # meta has been processed\n # TODO <a!> rstrip punctuation support\n # print(text) # for debug\n\n keys, values= ['text'], [text]\n for inputflag_name in self.registered_inputflag_names:\n keys.append(inputflag_name)\n v = None\n if hasattr(self, inputflag_name) and getattr(self, inputflag_name) is not None:\n v = getattr(self, inputflag_name)\n elif hasattr(self, \"get_default_\"+inputflag_name):\n v = getattr(self, \"get_default_\"+inputflag_name)()\n else:\n raise ValueError(\"\"\"\n Template's inputflag '{}' is registered but not initialize.\n Try using template.{} = [...] to initialize\n or create an method get_default_{}(self) in your template.\n \"\"\".format(inputflag_name, inputflag_name, inputflag_name))\n \n if len(v) != len(text):\n raise ValueError(\"Template: len({})={} doesn't match len(text)={}.\"\\\n .format(inputflag_name, len(v), len(text)))\n values.append(v)\n wrapped_parts_to_tokenize = []\n for piece in list(zip(*values)):\n wrapped_parts_to_tokenize.append(dict(zip(keys, piece)))\n\n wrapped_parts_not_tokenize = {key: getattr(example, key) for key in not_empty_keys}\n return [wrapped_parts_to_tokenize, wrapped_parts_not_tokenize]\n else:\n raise TypeError(\"InputExample\") \n \n @abstractmethod\n def process_batch(self, batch):\n r\"\"\"All template should rewrite this method to process the batch input\n such as substituting embeddings.\n \"\"\"\n raise NotImplementedError\n\n def save(self,\n path: str,\n **kwargs) -> None:\n r'''\n A save method API.\n \n Args:\n path (str): A path to save your template.\n '''\n raise NotImplementedError\n\n @property\n def text(self):\n return self._text\n\n @text.setter \n def text(self, text):\n self._text = text\n if text is None:\n return\n if (not isinstance(text, list)) and (not isinstance(text, tuple)):\n raise ValueError(\"Template text must be a list or a tuple\")\n if not self._in_on_text_set:\n self.safe_on_text_set()\n # else:\n # logger.warning(\"Reset text in on_text_set function. Is this intended?\")\n\n def safe_on_text_set(self) -> None:\n r\"\"\"With this wrapper function, setting text inside ``on_text_set()``\n will not trigger ``on_text_set()`` again to prevent endless recursion.\n \"\"\"\n self._in_on_text_sett = True\n self.on_text_set()\n self._in_on_text_set = False\n \n def on_text_set(self):\n r\"\"\"\n A hook to do something when template text was set.\n \"\"\"\n pass\n \n def from_file(self,\n path: str,\n choice: int = 0,\n separator: str = \" \",\n ):\n r'''\n Read the template from a local file.\n\n Args: \n path (:obj:`str`): The path of the local template file.\n choice (:obj:`int`): The id-th line of the file.\n separator (:obj:`str`, optional): A sparator to delimit the text in the file. Default to \" \"\n '''\n with open(path, 'r') as fin:\n text = fin.readlines()[choice]\n text = text.strip().split(separator)\n self.text = text\n return self\n\n @classmethod\n def from_config(cls,\n config: CfgNode,\n **kwargs):\n r\"\"\"load a template from template's configuration node. \n\n Args:\n config (:obj:`CfgNode`): the sub-configuration of template, i.e. config[config.template]\n if config is a global config node. \n kwargs: Other kwargs that might be used in initialize the verbalizer. \n The actual value should match the arguments of __init__ functions.\n \"\"\"\n\n init_args = signature(cls.__init__).args\n _init_dict = {**convert_cfg_to_dict(config), **kwargs}\n init_dict = {key: _init_dict[key] for key in _init_dict if key in init_args}\n template = cls(**init_dict)\n if hasattr(template, \"from_file\"):\n if not hasattr(config, \"file_path\"):\n pass\n else:\n if (not hasattr(config, \"text\") or config.text is None) and config.file_path is not None:\n if config.choice is None:\n config.choice = 0\n template.from_file(config.file_path, config.choice)\n elif (hasattr(config, \"text\") and config.text is not None) and config.file_path is not None:\n raise RuntimeError(\"The text can't be both set from `text` and `file_path`.\")\n return template\n \n\n\n\n\nclass Verbalizer(nn.Module):\n r'''\n Base class for all the verbalizers. \n\n Args: \n tokenizer (:obj:`PreTrainedTokenizer`): A tokenizer to appoint the vocabulary and the tokenization strategy.\n classes (:obj:`Sequence[str]`): A sequence of classes that need to be projected.\n '''\n def __init__(self,\n tokenizer: Optional[PreTrainedTokenizer] = None,\n classes: Optional[Sequence[str]] = None,\n num_classes: Optional[int] = None,\n ):\n super().__init__()\n self.tokenizer = tokenizer\n self.classes = classes\n if classes is not None and num_classes is not None:\n assert len(classes) == num_classes, \"len(classes) != num_classes, Check you config.\"\n self.num_classes = num_classes\n elif num_classes is not None:\n self.num_classes = num_classes\n elif classes is not None:\n self.num_classes = len(classes)\n else:\n self.num_classes = None\n # raise AttributeError(\"No able to configure num_classes\")\n self._in_on_label_words_set = False\n\n @property\n def label_words(self,):\n r'''\n Label words means the words in the vocabulary projected by the labels. \n E.g. if we want to establish a projection in sentiment classification: positive :math:`\\rightarrow` {`wonderful`, `good`},\n in this case, `wonderful` and `good` are label words.\n '''\n return self._label_words\n \n @label_words.setter\n def label_words(self, label_words):\n if label_words is None:\n return\n self._label_words = self._match_label_words_to_label_ids(label_words)\n if not self._in_on_label_words_set:\n self.safe_on_label_words_set()\n # else:\n # logger.warning(\"Reset label words in on_label_words_set function. Is this intended?\")\n\n def _match_label_words_to_label_ids(self, label_words): # TODO newly add function after docs written # TODO rename this function\n \"\"\"\n sort label words dict of verbalizer to match the label order of the classes\n \"\"\"\n if isinstance(label_words, dict):\n if self.classes is None:\n raise ValueError(\"\"\"\n classes attribute of the Verbalizer should be set since your given label words is a dict.\n Since we will match the label word with respect to class A, to A's index in classes\n \"\"\")\n if set(label_words.keys()) != set(self.classes):\n raise ValueError(\"name of classes in verbalizer are differnt from those of dataset\")\n label_words = [ # sort the dict to match dataset\n label_words[c]\n for c in self.classes\n ] # length: label_size of the whole task\n elif isinstance(label_words, list) or isinstance(label_words, tuple):\n pass\n # logger.info(\"\"\"\n # Your given label words is a list, by default, the ith label word in the list will match class i of the dataset.\n # Please make sure that they have the same order.\n # Or you can pass label words as a dict, mapping from class names to label words.\n # \"\"\")\n else:\n raise ValueError(\"Verbalizer label words must be list, tuple or dict\")\n return label_words\n\n def safe_on_label_words_set(self,):\n self._in_on_label_words_set = True\n self.on_label_words_set()\n self._in_on_label_words_set = False\n\n def on_label_words_set(self,):\n r\"\"\"A hook to do something when textual label words were set.\n \"\"\"\n pass\n\n @property\n def vocab(self,) -> Dict:\n if not hasattr(self, '_vocab'):\n self._vocab = self.tokenizer.convert_ids_to_tokens(np.arange(self.vocab_size).tolist())\n return self._vocab\n\n @property\n def vocab_size(self,) -> int:\n return self.tokenizer.vocab_size\n \n @abstractmethod\n def generate_parameters(self, **kwargs) -> List:\n r\"\"\"\n The verbalizer can be seen as an extra layer on top of the originial\n pre-trained models. In manual verbalizer, it is a fixed one-hot vector of dimension\n vocab_size, with the position of the label word being 1 and 0 everywhere else. \n In other situation, the parameters may be a continuous vector over the \n vocab, with each dimension representing a weight of that token.\n Moreover, the parameters may be set to trainable to allow label words selection.\n \n Therefore, this function serves as an abstract methods for generating the parameters\n of the verbalizer, and must be instantiated in any derived class.\n\n Note that the parameters need to be registered as a part of pytorch's module to \n It can be acheived by wrapping a tensor using nn.Parameter().\n \"\"\"\n raise NotImplementedError\n\n def register_calibrate_logits(self, logits: torch.Tensor):\n r\"\"\"\n This function aims to register logits that need to be calibrated, and detach the orginal logits from the current graph.\n See XX for more details.\n \"\"\"\n if logits.requires_grad:\n logits = logits.detach()\n self._calibrate_logits = logits\n \n def process_logits(self,\n logits: torch.Tensor,\n batch: InputFeatures,\n **kwargs):\n r\"\"\"Abstract method for process logits.\n \n Args:\n logits (:obj:`torch.Tensor`): The current logits generated by pre-trained language models.\n batch (:obj:`InputFeatures`): The input features of the data.\n \"\"\"\n raise NotImplementedError\n\n @staticmethod\n def aggregate(label_words_logits: torch.Tensor) -> torch.Tensor:\n r\"\"\" To aggregate logits on multiple label words into the label's logits\n Basic aggregator: mean of each label words' logits to a label's logits\n Can be re-implemented in advanced verbaliezer.\n\n Args:\n label_words_logits (:obj:`torch.Tensor`): The logits of the label words only.\n\n Return:\n :obj:`torch.Tensor`: The final logits calculated by the label words.\n \"\"\"\n if label_words_logits.dim()>2:\n return label_words_logits.mean(dim=-1)\n else:\n return label_words_logits\n\n\n def normalize(self, logits: torch.Tensor) -> torch.Tensor:\n r\"\"\"\n Given logits regarding the entire vocab, calculate the probs over the label words set by softmax.\n \n Args:\n logits(:obj:`Tensor`): The logits of the entire vocab.\n\n Returns:\n :obj:`Tensor`: The probability distribution over the label words set.\n \"\"\"\n batch_size = logits.shape[0]\n return F.softmax(logits.reshape(batch_size, -1), dim=-1).reshape(*logits.shape)\n\n @abstractmethod\n def project(self,\n logits: torch.Tensor,\n **kwargs) -> torch.Tensor:\n r\"\"\"This method receives input logits of shape (batch_size, vocab_size), and use the \n parameters of this verbalizer to project the logits over entire vocab into the\n logits of labels words. \n\n Args: \n logits (:obj:`Tensor`): The logits over entire vocab generated by the pre-trained lanuage model with shape [``batch_size``, ``max_seq_length``, ``vocab_size``] \n \n Returns:\n :obj:`Tensor`: The normalized probs (sum to 1) of each label .\n \"\"\"\n raise NotImplementedError\n \n def handle_multi_token(self, label_words_logits, mask):\n r\"\"\"\n Support multiple methods to handle the multi tokens produced by the tokenizer.\n We suggest using 'first' or 'max' if the some parts of the tokenization is not meaningful.\n Can broadcast to 3-d tensor.\n \n Args:\n label_words_logits (:obj:`torch.Tensor`):\n \n Returns:\n :obj:`torch.Tensor`\n \"\"\"\n if self.multi_token_handler == \"first\":\n label_words_logits = label_words_logits.select(dim=-1, index=0)\n elif self.multi_token_handler == \"max\":\n label_words_logits = label_words_logits - 1000*(1-mask.unsqueeze(0))\n label_words_logits = label_words_logits.max(dim=-1).values\n elif self.multi_token_handler == \"mean\":\n label_words_logits = (label_words_logits*mask.unsqueeze(0)).sum(dim=-1)/(mask.unsqueeze(0).sum(dim=-1)+1e-15)\n else:\n raise ValueError(\"multi_token_handler {} not configured\".format(self.multi_token_handler))\n return label_words_logits\n \n @classmethod\n def from_config(cls, \n config: CfgNode, \n **kwargs):\n r\"\"\"load a verbalizer from verbalizer's configuration node. \n\n Args:\n config (:obj:`CfgNode`): the sub-configuration of verbalizer, i.e. config[config.verbalizer]\n if config is a global config node. \n kwargs: Other kwargs that might be used in initialize the verbalizer. \n The actual value should match the arguments of __init__ functions.\n \"\"\"\n\n init_args = signature(cls.__init__).args\n _init_dict = {**convert_cfg_to_dict(config), **kwargs}\n init_dict = {key: _init_dict[key] for key in _init_dict if key in init_args}\n verbalizer = cls(**init_dict)\n if hasattr(verbalizer, \"from_file\"):\n if not hasattr(config, \"file_path\"):\n pass\n else:\n if (not hasattr(config, \"label_words\") or config.label_words is None) and config.file_path is not None:\n if config.choice is None:\n config.choice = 0\n verbalizer.from_file(config.file_path, config.choice)\n elif (hasattr(config, \"label_words\") and config.label_words is not None) and config.file_path is not None:\n raise RuntimeError(\"The text can't be both set from `text` and `file_path`.\")\n return verbalizer\n \n def from_file(self,\n path: str, \n choice: Optional[int] = 0 ):\n r\"\"\"Load the predefined label words from verbalizer file.\n Currently support three types of file format:\n 1. a .jsonl or .json file, in which is a single verbalizer \n in dict format.\n 2. a .jsonal or .json file, in which is a list of verbalizers in dict format\n 3. a .txt or a .csv file, in which is the label words of a class are listed in line, \n seperated by commas. Begin a new verbalizer by an empty line.\n This format is recommended when you don't know the name of each class.\n\n The details of verbalizer format can be seen in :ref:`How_to_write_a_verbalizer`. \n\n Args: \n path (:obj:`str`): The path of the local template file.\n choice (:obj:`int`): The choice of verbalizer in a file containing\n multiple verbalizers.\n \n Returns:\n Template : `self` object\n \"\"\"\n if path.endswith(\".txt\") or path.endswith(\".csv\"):\n with open(path, 'r') as f:\n lines = f.readlines()\n label_words_all = []\n label_words_single_group = []\n for line in lines:\n line = line.strip().strip(\" \")\n if line == \"\":\n if len(label_words_single_group)>0:\n label_words_all.append(label_words_single_group)\n label_words_single_group = []\n else:\n label_words_single_group.append(line)\n if len(label_words_single_group) > 0: # if no empty line in the last\n label_words_all.append(label_words_single_group)\n if choice >= len(label_words_all):\n raise RuntimeError(\"choice {} exceed the number of verbalizers {}\"\n .format(choice, len(label_words_all)))\n\n label_words = label_words_all[choice]\n label_words = [label_words_per_label.strip().split(\",\") \\\n for label_words_per_label in label_words]\n \n elif path.endswith(\".jsonl\") or path.endswith(\".json\"):\n with open(path, \"r\") as f:\n label_words_all = json.load(f)\n # if it is a file containing multiple verbalizers\n if isinstance(label_words_all, list):\n if choice >= len(label_words_all):\n raise RuntimeError(\"choice {} exceed the number of verbalizers {}\"\n .format(choice, len(label_words_all)))\n label_words = label_words_all[choice]\n elif isinstance(label_words_all, dict):\n label_words = label_words_all\n if choice>0:\n logger.warning(\"Choice of verbalizer is 1, but the file \\\n only contains one verbalizer.\")\n \n self.label_words = label_words\n if self.num_classes is not None:\n num_classes = len(self.label_words)\n assert num_classes==self.num_classes, 'number of classes in the verbalizer file\\\n does not match the predefined num_classes.'\n return self\n\n"
] | [
[
"torch.log",
"torch.tensor",
"torch.nn.Parameter"
],
[
"numpy.arange"
]
] |
Ascend/modelzoo | [
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509",
"f018cfed33dbb1cc2110b9ea2e233333f71cc509"
] | [
"built-in/PyTorch/Official/cv/image_classification/Gluon_ResNet50_v1d_for_PyTorch/timm/optim/radam.py",
"built-in/ACL_TensorFlow/Official/recommendation/DCN_for_ACL/scripts/eval.py",
"built-in/ACL_TensorFlow/Official/recommendation/KGAT_for_ACL/Model/offline_inference/xacl_inference.py",
"built-in/PyTorch/Official/cv/image_object_detection/YoloV3_ID1790_for_PyTorch/tools/publish_model.py",
"built-in/PyTorch/Official/cv/image_object_detection/YoloV3_ID1790_for_PyTorch/mmcv_need/distributed.py",
"built-in/PyTorch/Official/cv/scene_text_detection/PSENet_for_PyTorch/NPU/test/test_npu.py",
"contrib/PyTorch/Official/cv/image_classification/SPNASNet_100_for_PyTorch/timm/models/layers/test_time_pool.py",
"built-in/TensorFlow/Official/cv/image_classification/Resnet50v1.5_for_TensorFlow/01-generalization/01-inference/02-offlineInfer/resnet50tf_for_ACL/script/cv2bin.py",
"built-in/TensorFlow/Official/cv/detection/SSD-Resnet34_for_TensorFlow/dataloader.py",
"contrib/TensorFlow/Official/cv/east/EAST_ID0238_for_TensorFlow/npu_train.py",
"built-in/MindSpore/Official/nlp/TinyBERT_for_MindSpore/src/tinybert_model.py",
"built-in/ACL_TensorFlow/Official/cv/YOLOv2_for_ACL/scripts/yolov2_postprocess/script/Main.py",
"built-in/PyTorch/Official/cv/image_object_detection/Faster_Mask_RCNN_for_PyTorch_Dynamic_Shape/detectron2/export/caffe2_inference.py",
"built-in/PyTorch/Official/cv/semantic_segmentation/AttU_Net_for_PyTorch/solver.py",
"built-in/PyTorch/Official/cv/image_classification/Gluon_ResNet50_v1c_for_PyTorch/timm/optim/adamw.py",
"built-in/PyTorch/Official/cv/semantic_segmentation/DeepLabv3+_ID1695_for_PyTorch/dataloaders/utils.py",
"built-in/TensorFlow/Official/cv/detection/CRNN_for_TensorFlow/local_utils/evaluation_tools.py",
"built-in/PyTorch/Official/cv/image_object_detection/YOLOV4_ID0396_for_PyTorch/train.py",
"built-in/MindSpore/Official/ocr/CRNN_for_MindSpore/infer/sdk/compute_crnn_sdk_opencv.py",
"built-in/PyTorch/Official/cv/image_classification/Gluon_ResNet50_v1c_for_PyTorch/timm/data/tf_preprocessing.py",
"built-in/PyTorch/Official/cv/image_classification/DenseNet169_ID0454_for_Pytorch/torchvision/models/detection/mask_rcnn.py",
"built-in/ACL_TensorFlow/Official/cv/3DUNET_for_ACL/scripts/transforms.py",
"built-in/PyTorch/Official/cv/image_object_detection/Faster_Mask_RCNN_for_PyTorch_Dynamic_Shape/detectron2/engine/train_loop.py",
"contrib/PyTorch/Official/cv/image_classification/SPNASNet_100_for_PyTorch/pthtar2onnx.py",
"built-in/PyTorch/Official/cv/image_classification/MobileNetV2_for_PyTorch/train/modelarts/train_start.py",
"built-in/TensorFlow/Official/cv/detection/SSD-Resnet34_for_TensorFlow/infer_from_pb.py",
"built-in/TensorFlow/Official/cv/image_classification/MobileNetV2_for_TensorFlow/nets/resnet_v2.py"
] | [
"# Copyright [yyyy] [name of copyright owner]\n# Copyright 2021 Huawei Technologies Co., Ltd\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\n\"\"\"RAdam Optimizer.\nImplementation lifted from: https://github.com/LiyuanLucasLiu/RAdam\nPaper: `On the Variance of the Adaptive Learning Rate and Beyond` - https://arxiv.org/abs/1908.03265\n\"\"\"\nimport math\nimport torch\nfrom torch.optim.optimizer import Optimizer, required\n\n\nclass RAdam(Optimizer):\n\n def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0):\n defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)\n self.buffer = [[None, None, None] for ind in range(10)]\n super(RAdam, self).__init__(params, defaults)\n\n def __setstate__(self, state):\n super(RAdam, self).__setstate__(state)\n\n def step(self, closure=None):\n\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data.float()\n if grad.is_sparse:\n raise RuntimeError('RAdam does not support sparse gradients')\n\n p_data_fp32 = p.data.float()\n\n state = self.state[p]\n\n if len(state) == 0:\n state['step'] = 0\n state['exp_avg'] = torch.zeros_like(p_data_fp32)\n state['exp_avg_sq'] = torch.zeros_like(p_data_fp32)\n else:\n state['exp_avg'] = state['exp_avg'].type_as(p_data_fp32)\n state['exp_avg_sq'] = state['exp_avg_sq'].type_as(p_data_fp32)\n\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n beta1, beta2 = group['betas']\n\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n\n state['step'] += 1\n buffered = self.buffer[int(state['step'] % 10)]\n if state['step'] == buffered[0]:\n N_sma, step_size = buffered[1], buffered[2]\n else:\n buffered[0] = state['step']\n beta2_t = beta2 ** state['step']\n N_sma_max = 2 / (1 - beta2) - 1\n N_sma = N_sma_max - 2 * state['step'] * beta2_t / (1 - beta2_t)\n buffered[1] = N_sma\n\n # more conservative since it's an approximated value\n if N_sma >= 5:\n step_size = group['lr'] * math.sqrt(\n (1 - beta2_t) * (N_sma - 4) / (N_sma_max - 4) * (N_sma - 2) / N_sma * N_sma_max / (\n N_sma_max - 2)) / (1 - beta1 ** state['step'])\n else:\n step_size = group['lr'] / (1 - beta1 ** state['step'])\n buffered[2] = step_size\n\n if group['weight_decay'] != 0:\n p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)\n\n # more conservative since it's an approximated value\n if N_sma >= 5:\n denom = exp_avg_sq.sqrt().add_(group['eps'])\n p_data_fp32.addcdiv_(-step_size, exp_avg, denom)\n else:\n p_data_fp32.add_(-step_size, exp_avg)\n\n p.data.copy_(p_data_fp32)\n\n return loss\n\n\nclass PlainRAdam(Optimizer):\n\n def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0):\n defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)\n\n super(PlainRAdam, self).__init__(params, defaults)\n\n def __setstate__(self, state):\n super(PlainRAdam, self).__setstate__(state)\n\n def step(self, closure=None):\n\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data.float()\n if grad.is_sparse:\n raise RuntimeError('RAdam does not support sparse gradients')\n\n p_data_fp32 = p.data.float()\n\n state = self.state[p]\n\n if len(state) == 0:\n state['step'] = 0\n state['exp_avg'] = torch.zeros_like(p_data_fp32)\n state['exp_avg_sq'] = torch.zeros_like(p_data_fp32)\n else:\n state['exp_avg'] = state['exp_avg'].type_as(p_data_fp32)\n state['exp_avg_sq'] = state['exp_avg_sq'].type_as(p_data_fp32)\n\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n beta1, beta2 = group['betas']\n\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n\n state['step'] += 1\n beta2_t = beta2 ** state['step']\n N_sma_max = 2 / (1 - beta2) - 1\n N_sma = N_sma_max - 2 * state['step'] * beta2_t / (1 - beta2_t)\n\n if group['weight_decay'] != 0:\n p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)\n\n # more conservative since it's an approximated value\n if N_sma >= 5:\n step_size = group['lr'] * math.sqrt(\n (1 - beta2_t) * (N_sma - 4) / (N_sma_max - 4) * (N_sma - 2) / N_sma * N_sma_max / (\n N_sma_max - 2)) / (1 - beta1 ** state['step'])\n denom = exp_avg_sq.sqrt().add_(group['eps'])\n p_data_fp32.addcdiv_(-step_size, exp_avg, denom)\n else:\n step_size = group['lr'] / (1 - beta1 ** state['step'])\n p_data_fp32.add_(-step_size, exp_avg)\n\n p.data.copy_(p_data_fp32)\n\n return loss\n",
"# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n# Copyright 2021 Huawei Technologies Co., Ltd\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\nfrom sklearn.metrics import average_precision_score, roc_auc_score\nimport numpy as np\nimport sys\n\ndef aucPerformance(mse, labels):\n \"\"\"\n :param mse:\n :param labels:\n :return:\n \"\"\"\n roc_auc = roc_auc_score(labels, mse)\n ap = average_precision_score(labels, mse)\n print(\"AUC-ROC: %.4f, AUC-PR: %.4f\" % (roc_auc, ap))\n return roc_auc, ap\n\n\ndef eval_om(label_dir, om_output_dir):\n \"\"\"\n :param label_dir:\n :param om_output_dir:\n :return:\n \"\"\"\n label, score = read_directory(label_dir, om_output_dir)\n aucPerformance(score, label)\n\n\ndef read_directory(label_dir, om_output_dir):\n \"\"\"\n :param label_dir:\n :param om_output_dir:\n :return:\n \"\"\"\n # get label bin files\n labels = os.listdir(label_dir)\n labels.sort()\n labels_data = list()\n\n # get om output files\n outputs = os.listdir(om_output_dir)\n outputs.sort()\n outputs_data = list()\n\n for i in range(len(outputs)):\n label_data = np.fromfile(os.path.join(label_dir, labels[i]), dtype=np.int32)\n labels_data.extend(label_data)\n output_data = np.fromfile(os.path.join(om_output_dir, outputs[i]), dtype=np.float32)\n outputs_data.extend(output_data)\n return labels_data, outputs_data\n\ngt_dir = sys.argv[1]\npredict_dir = sys.argv[2]\neval_om(gt_dir, predict_dir)\n",
"# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n# Copyright 2021 Huawei Technologies Co., Ltd\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\nimport numpy as np\nimport multiprocessing\nimport sys\nsys.path.append('./')\nfrom utility.batch_test import cores, Ks, BATCH_SIZE, ITEM_NUM, data_generator, test_one_user\nfrom utility.parser import parse_args\n\n\ndef xaclPath(output_path, inference_path, model_path):\n \"\"\"\n 使用文件夹推理\n \"\"\"\n if os.path.isdir(inference_path):\n os.system(\"rm -rf \" + inference_path)\n os.makedirs(inference_path)\n output_path = output_path if output_path[-1] == \"/\" else output_path + \"/\"\n output_path_lst = [output_path + \"input1\", output_path + \"input2\", output_path + \"input3\"]\n output_paths = ','.join(output_path_lst)\n print(\"xacl_fmk -m \" + model_path + \" -i \" + output_paths +\n \" -o \" + inference_path + '/kgat_output_bin')\n os.system(\"xacl_fmk -m \" + model_path + \" -i \" +\n output_paths + \" -o \" + inference_path + '/kgat_output_bin')\n print(inference_path)\n print(\"[INFO] 推理结果生成结束\")\n\n\ndef inference_files(inference_path):\n result = {'precision': np.zeros(len(Ks)), 'recall': np.zeros(len(Ks)), 'ndcg': np.zeros(len(Ks)),\n 'hit_ratio': np.zeros(len(Ks)), 'auc': 0.}\n\n pool = multiprocessing.Pool(cores)\n\n u_batch_size = BATCH_SIZE * 2\n\n users_to_test = list(data_generator.test_user_dict.keys())\n test_users = users_to_test\n n_test_users = len(test_users)\n\n files = sorted(os.listdir(inference_path))\n files = [inference_path + '/' + i for i in files]\n\n for u_batch_id, f in enumerate(files):\n if f.endswith(\".bin\"):\n rate_batch = np.fromfile(f, dtype='float32')\n rate_batch = rate_batch.reshape((-1, ITEM_NUM))\n\n start = u_batch_id * u_batch_size\n end = (u_batch_id + 1) * u_batch_size\n\n user_batch = test_users[start: end]\n\n user_batch_rating_uid = zip(rate_batch, user_batch)\n batch_result = pool.map(test_one_user, user_batch_rating_uid)\n\n for re in batch_result:\n result['precision'] += re['precision'] / n_test_users\n result['recall'] += re['recall'] / n_test_users\n result['ndcg'] += re['ndcg'] / n_test_users\n result['hit_ratio'] += re['hit_ratio'] / n_test_users\n result['auc'] += re['auc'] / n_test_users\n pool.close()\n print(result)\n\n\nif __name__ == '__main__':\n args = parse_args()\n\n output_path = args.output_path\n inference_path = args.inference_path\n model_path = args.model_path\n\n xaclPath(output_path, inference_path, model_path)\n inference_files(inference_path)\n",
"# Copyright 2021 Huawei Technologies Co., Ltd\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 argparse\nimport subprocess\n\nimport torch\n\n\ndef parse_args():\n parser = argparse.ArgumentParser(\n description='Process a checkpoint to be published')\n parser.add_argument('in_file', help='input checkpoint filename')\n parser.add_argument('out_file', help='output checkpoint filename')\n args = parser.parse_args()\n return args\n\n\ndef process_checkpoint(in_file, out_file):\n checkpoint = torch.load(in_file, map_location='cpu')\n # remove optimizer for smaller file size\n if 'optimizer' in checkpoint:\n del checkpoint['optimizer']\n # if it is necessary to remove some sensitive data in checkpoint['meta'],\n # add the code here.\n torch.save(checkpoint, out_file)\n sha = subprocess.check_output(['sha256sum', out_file]).decode()\n if out_file.endswith('.pth'):\n out_file_name = out_file[:-4]\n else:\n out_file_name = out_file\n final_file = out_file_name + f'-{sha[:8]}.pth'\n subprocess.Popen(['mv', out_file, final_file])\n\n\ndef main():\n args = parse_args()\n process_checkpoint(args.in_file, args.out_file)\n\n\nif __name__ == '__main__':\n main()\n",
"# Copyright 2021 Huawei Technologies Co., Ltd\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 torch\nfrom torch.nn.parallel.distributed import (DistributedDataParallel,\n _find_tensors)\n\nfrom mmcv import print_log\nfrom mmcv.utils import TORCH_VERSION\nfrom .scatter_gather import scatter_kwargs\n\n\nclass MMDistributedDataParallel(DistributedDataParallel):\n \"\"\"The DDP module that supports DataContainer.\n\n MMDDP has two main differences with PyTorch DDP:\n\n - It supports a custom type :class:`DataContainer` which allows more\n flexible control of input data.\n - It implement two APIs ``train_step()`` and ``val_step()``.\n \"\"\"\n\n def scatter(self, inputs, kwargs, device_ids):\n return scatter_kwargs(inputs, kwargs, device_ids, dim=self.dim)\n\n def train_step(self, *inputs, **kwargs):\n \"\"\"train_step() API for module wrapped by DistributedDataParallel.\n\n This method is basically the same as\n ``DistributedDataParallel.forward()``, while replacing\n ``self.module.forward()`` with ``self.module.train_step()``.\n It is compatible with PyTorch 1.1 - 1.5.\n \"\"\"\n\n # In PyTorch >= 1.7, ``reducer._rebuild_buckets()`` is moved from the\n # end of backward to the beginning of forward.\n if (TORCH_VERSION >= '1.7' and 'parrots'\n not in TORCH_VERSION) and self.reducer._rebuild_buckets():\n print_log(\n 'Reducer buckets have been rebuilt in this iteration.',\n logger='mmcv')\n\n if getattr(self, 'require_forward_param_sync', True):\n self._sync_params()\n if self.device_ids and False:\n inputs, kwargs = self.scatter(inputs, kwargs, self.device_ids)\n if len(self.device_ids) == 1:\n output = self.module.train_step(*inputs[0], **kwargs[0])\n else:\n outputs = self.parallel_apply(\n self._module_copies[:len(inputs)], inputs, kwargs)\n output = self.gather(outputs, self.output_device)\n else:\n inputs, kwargs = self.scatter(inputs, kwargs, [-1])\n output = self.module.train_step(*inputs[0], **kwargs[0])\n\n if torch.is_grad_enabled() and getattr(\n self, 'require_backward_grad_sync', True):\n if self.find_unused_parameters:\n self.reducer.prepare_for_backward(list(_find_tensors(output)))\n else:\n self.reducer.prepare_for_backward([])\n else:\n if TORCH_VERSION > '1.2':\n self.require_forward_param_sync = False\n return output\n\n def val_step(self, *inputs, **kwargs):\n \"\"\"val_step() API for module wrapped by DistributedDataParallel.\n\n This method is basically the same as\n ``DistributedDataParallel.forward()``, while replacing\n ``self.module.forward()`` with ``self.module.val_step()``.\n It is compatible with PyTorch 1.1 - 1.5.\n \"\"\"\n # In PyTorch >= 1.7, ``reducer._rebuild_buckets()`` is moved from the\n # end of backward to the beginning of forward.\n if (TORCH_VERSION >= '1.7' and 'parrots'\n not in TORCH_VERSION) and self.reducer._rebuild_buckets():\n print_log(\n 'Reducer buckets have been rebuilt in this iteration.',\n logger='mmcv')\n\n if getattr(self, 'require_forward_param_sync', True):\n self._sync_params()\n if self.device_ids:\n inputs, kwargs = self.scatter(inputs, kwargs, self.device_ids)\n if len(self.device_ids) == 1:\n output = self.module.val_step(*inputs[0], **kwargs[0])\n else:\n outputs = self.parallel_apply(\n self._module_copies[:len(inputs)], inputs, kwargs)\n output = self.gather(outputs, self.output_device)\n else:\n output = self.module.val_step(*inputs, **kwargs)\n\n if torch.is_grad_enabled() and getattr(\n self, 'require_backward_grad_sync', True):\n if self.find_unused_parameters:\n self.reducer.prepare_for_backward(list(_find_tensors(output)))\n else:\n self.reducer.prepare_for_backward([])\n else:\n if TORCH_VERSION > '1.2':\n self.require_forward_param_sync = False\n return output\n",
"# Copyright [yyyy] [name of copyright owner]\n# Copyright 2020 Huawei Technologies Co., Ltd\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 argparse\nimport collections\nimport os\nimport sys\nimport time\n\nimport cv2\nimport numpy as np\nimport torch\nfrom torch.utils import data\n\nimport models\nimport util\nfrom dataset import IC15TestLoader\n# c++ version pse based on opencv 3+\n# from pse import pse\n# python pse\nfrom pypse import pse as pypse\n\n\ndef extend_3c(img):\n img = img.reshape(img.shape[0], img.shape[1], 1)\n img = np.concatenate((img, img, img), axis=2)\n return img\n\n\ndef debug(idx, img_paths, imgs, output_root):\n if not os.path.exists(output_root):\n os.makedirs(output_root)\n\n col = []\n for i in range(len(imgs)):\n row = []\n for j in range(len(imgs[i])):\n # img = cv2.copyMakeBorder(imgs[i][j], 3, 3, 3, 3, cv2.BORDER_CONSTANT, value=[255, 0, 0])\n row.append(imgs[i][j])\n res = np.concatenate(row, axis=1)\n col.append(res)\n res = np.concatenate(col, axis=0)\n img_name = img_paths[idx].split('/')[-1]\n print(idx, '/', len(img_paths), img_name)\n cv2.imwrite(output_root + img_name, res)\n\n\ndef write_result_as_txt(image_name, bboxes, path):\n if not os.path.exists(path):\n os.mkdir(path)\n filename = util.io.join_path(path, 'res_%s.txt' % (image_name))\n lines = []\n for b_idx, bbox in enumerate(bboxes):\n values = [int(v) for v in bbox]\n line = \"%d, %d, %d, %d, %d, %d, %d, %d\\n\" % tuple(values)\n lines.append(line)\n util.io.write_lines(filename, lines)\n\n\ndef polygon_from_points(points):\n \"\"\"\n Returns a Polygon object to use with the Polygon2 class from a list of 8 points: x1,y1,x2,y2,x3,y3,x4,y4\n \"\"\"\n resBoxes = np.empty([1, 8], dtype='int32')\n resBoxes[0, 0] = int(points[0])\n resBoxes[0, 4] = int(points[1])\n resBoxes[0, 1] = int(points[2])\n resBoxes[0, 5] = int(points[3])\n resBoxes[0, 2] = int(points[4])\n resBoxes[0, 6] = int(points[5])\n resBoxes[0, 3] = int(points[6])\n resBoxes[0, 7] = int(points[7])\n pointMat = resBoxes[0].reshape([2, 4]).T\n return plg.Polygon(pointMat)\n\n\[email protected]_grad()\ndef test(args):\n data_loader = IC15TestLoader(long_size=args.long_size, datadir=args.data_dir)\n test_loader = torch.utils.data.DataLoader(\n data_loader,\n batch_size=1,\n shuffle=False,\n num_workers=1,\n drop_last=True)\n\n # Setup Model\n if args.arch == \"resnet50\":\n model = models.resnet50(pretrained=True, num_classes=7, scale=args.scale)\n elif args.arch == \"resnet101\":\n model = models.resnet101(pretrained=True, num_classes=7, scale=args.scale)\n elif args.arch == \"resnet152\":\n model = models.resnet152(pretrained=True, num_classes=7, scale=args.scale)\n\n for param in model.parameters():\n param.requires_grad = False\n\n model = model.to(CALCULATE_DEVICE)\n\n if args.resume is not None:\n if os.path.isfile(args.resume):\n print(\"Loading model and optimizer from checkpoint '{}'\".format(args.resume))\n checkpoint = torch.load(args.resume, map_location=CALCULATE_DEVICE)\n\n # model.load_state_dict(checkpoint['state_dict'])\n d = collections.OrderedDict()\n for key, value in checkpoint['state_dict'].items():\n if key.startswith('module.'):\n tmp = key[7:]\n else:\n tmp = key\n d[tmp] = value\n model.load_state_dict(d)\n\n print(\"Loaded checkpoint '{}' (epoch {})\"\n .format(args.resume, checkpoint['epoch']))\n sys.stdout.flush()\n else:\n print(\"No checkpoint found at '{}'\".format(args.resume))\n sys.stdout.flush()\n\n model.eval()\n total_frame = 0.0\n total_time = 0.0\n for idx, (org_img, img) in enumerate(test_loader):\n print('progress: %d / %d' % (idx, len(test_loader)))\n sys.stdout.flush()\n\n img = img.to(CALCULATE_DEVICE)\n org_img = org_img.numpy().astype('uint8')[0]\n text_box = org_img.copy()\n\n torch.npu.synchronize()\n start = time.time()\n outputs = model(img)\n\n score = torch.sigmoid(outputs[:, 0, :, :])\n outputs = (torch.sign(outputs - args.binary_th) + 1) / 2\n\n text = outputs[:, 0, :, :]\n kernels = outputs[:, 0:args.kernel_num, :, :] * text\n\n score = score.data.cpu().numpy()[0].astype(np.float32)\n text = text.data.cpu().numpy()[0].astype(np.uint8)\n kernels = kernels.data.cpu().numpy()[0].astype(np.uint8)\n\n # c++ version pse\n # pred = pse(kernels, args.min_kernel_area / (args.scale * args.scale))\n # python version pse\n pred = pypse(kernels, args.min_kernel_area / (args.scale * args.scale))\n print(pred.shape)\n\n # scale = (org_img.shape[0] * 1.0 / pred.shape[0], org_img.shape[1] * 1.0 / pred.shape[1])\n scale = (org_img.shape[1] * 1.0 / pred.shape[1], org_img.shape[0] * 1.0 / pred.shape[0])\n label = pred\n label_num = np.max(label) + 1\n bboxes = []\n for i in range(1, label_num):\n points = np.array(np.where(label == i)).transpose((1, 0))[:, ::-1]\n\n if points.shape[0] < args.min_area / (args.scale * args.scale):\n continue\n\n score_i = np.mean(score[label == i])\n if score_i < args.min_score:\n continue\n\n rect = cv2.minAreaRect(points)\n bbox = cv2.boxPoints(rect) * scale\n bbox = bbox.astype('int32')\n bboxes.append(bbox.reshape(-1))\n\n torch.npu.synchronize()\n end = time.time()\n total_frame += 1\n total_time += (end - start)\n print('fps: %.2f' % (total_frame / total_time))\n sys.stdout.flush()\n\n for bbox in bboxes:\n cv2.drawContours(text_box, [bbox.reshape(4, 2)], -1, (0, 255, 0), 2)\n\n image_name = data_loader.img_paths[idx].split('/')[-1].split('.')[0]\n write_result_as_txt(image_name, bboxes, 'outputs/' + args.output_file)\n\n # text_box = cv2.resize(text_box, (text.shape[1], text.shape[0]))\n # debug(idx, data_loader.img_paths, [[text_box]], 'outputs/vis_ic15/')\n\n cmd = 'cd %s;zip -j %s %s/*' % ('./outputs/', args.output_file + '.zip', args.output_file)\n print(cmd)\n sys.stdout.flush()\n util.cmd.cmd(cmd)\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(description='Hyperparams')\n parser.add_argument('--arch', nargs='?', type=str, default='resnet50')\n parser.add_argument('--resume', nargs='?', type=str, default=None,\n help='Path to previous saved model to restart from')\n parser.add_argument('--binary_th', nargs='?', type=float, default=1.0,\n help='Path to previous saved model to restart from')\n parser.add_argument('--kernel_num', nargs='?', type=int, default=7,\n help='Path to previous saved model to restart from')\n parser.add_argument('--scale', nargs='?', type=int, default=1,\n help='Path to previous saved model to restart from')\n parser.add_argument('--long_size', nargs='?', type=int, default=2240,\n help='Path to previous saved model to restart from')\n parser.add_argument('--min_kernel_area', nargs='?', type=float, default=5.0,\n help='min kernel area')\n parser.add_argument('--min_area', nargs='?', type=float, default=800.0,\n help='min area')\n parser.add_argument('--min_score', nargs='?', type=float, default=0.93,\n help='min score')\n parser.add_argument('--npu', default=None, type=int,\n help='NPU id to use.')\n parser.add_argument('--data_dir', default='./data/ICDAR/Challenge/', type=str)\n parser.add_argument('--output_file', default='submit_ic15', type=str)\n args = parser.parse_args()\n CALCULATE_DEVICE = f\"npu:{args.npu}\"\n PRINT_DEVICE = \"cpu\"\n torch.npu.set_device(CALCULATE_DEVICE)\n test(args)\n",
"# Copyright 2020 Huawei Technologies Co., Ltd\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\"\"\" Test Time Pooling (Average-Max Pool)\n\nHacked together by / Copyright 2020 Ross Wightman\n\"\"\"\n\nimport logging\nfrom torch import nn\nimport torch.nn.functional as F\n\nfrom .adaptive_avgmax_pool import adaptive_avgmax_pool2d\n\n\n_logger = logging.getLogger(__name__)\n\n\nclass TestTimePoolHead(nn.Module):\n def __init__(self, base, original_pool=7):\n super(TestTimePoolHead, self).__init__()\n self.base = base\n self.original_pool = original_pool\n base_fc = self.base.get_classifier()\n if isinstance(base_fc, nn.Conv2d):\n self.fc = base_fc\n else:\n self.fc = nn.Conv2d(\n self.base.num_features, self.base.num_classes, kernel_size=1, bias=True)\n self.fc.weight.data.copy_(base_fc.weight.data.view(self.fc.weight.size()))\n self.fc.bias.data.copy_(base_fc.bias.data.view(self.fc.bias.size()))\n self.base.reset_classifier(0) # delete original fc layer\n\n def forward(self, x):\n x = self.base.forward_features(x)\n x = F.avg_pool2d(x, kernel_size=self.original_pool, stride=1)\n x = self.fc(x)\n x = adaptive_avgmax_pool2d(x, 1)\n return x.view(x.size(0), -1)\n\n\ndef apply_test_time_pool(model, config, use_test_size=True):\n test_time_pool = False\n if not hasattr(model, 'default_cfg') or not model.default_cfg:\n return model, False\n if use_test_size and 'test_input_size' in model.default_cfg:\n df_input_size = model.default_cfg['test_input_size']\n else:\n df_input_size = model.default_cfg['input_size']\n if config['input_size'][-1] > df_input_size[-1] and config['input_size'][-2] > df_input_size[-2]:\n _logger.info('Target input size %s > pretrained default %s, using test time pooling' %\n (str(config['input_size'][-2:]), str(df_input_size[-2:])))\n model = TestTimePoolHead(model, original_pool=model.default_cfg['pool_size'])\n test_time_pool = True\n return model, test_time_pool\n",
"import os\nimport sys\nimport cv2\nimport numpy as np\nfrom PIL import Image\n\nimage_root = r'./image-50000'\nresize_min = 256\n\ndef trans():\n images = os.listdir(image_root)\n for image_name in images:\n if image_name.endswith(\"txt\"):\n continue\n # image_name = \"20180522135150.jpg\"\n print(\"the image name is {}....\".format(image_name))\n image_path = os.path.join(image_root, image_name)\n # image = read_image(image_path, 1)\n # img = Image.open(image_path)\n img = cv2.imread(image_path)\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n '''\n img = img.astype(np.float32)\n cv2.normalize(img, img, 0, 1, cv2.NORM_MINMAX)\n '''\n # height, width = img.size\n height = img.shape[1]\n width = img.shape[0]\n # print('=====',height,width)\n smaller_dim = np.minimum(height, width)\n scale_ratio = resize_min / smaller_dim\n new_height = int(height * scale_ratio)\n new_width = int(width * scale_ratio)\n # img = img.resize((new_height, new_width)) ##\n\n img = cv2.resize(img, (new_height, new_width))\n\n img = np.array(img)\n if len(img.shape) != 3:\n continue\n height, width, c = img.shape\n crop_height = crop_width = 224\n amount_to_be_cropped_h = (height - crop_height)\n crop_top = amount_to_be_cropped_h // 2\n amount_to_be_cropped_w = (width - crop_width)\n crop_left = amount_to_be_cropped_w // 2\n img = img[crop_top:crop_top + crop_height, crop_left:crop_left + crop_width] ##[y0:y1,x0:x1]\n\n #img = np.array(img,dtype=np.float32)[np.newaxis, :, :, :]\n # means = [103.939, 116.779,123.68 ]\n means = [123.68, 116.779, 103.939]\n #means = np.array(means, dtype=np.float32)\n img = img - means \n img = np.array(img,dtype=np.float32)[np.newaxis, :, :, :]\n #print('===',img.shape)\n #print('===',img.size)\n\n\n img.tofile('./cv2bin-50000-xzm/{}.bin'.format(image_name))\n # print(image)\n # print(image.dtype)\n # print(image.shape)\ntrans()\n",
"# Copyright 2018 Google. 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\"\"\"Data loader and processing.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport itertools as it\nimport math\nimport os\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom object_detection import argmax_matcher\nfrom object_detection import box_list\nfrom object_detection import faster_rcnn_box_coder\nfrom object_detection import preprocessor\nfrom object_detection import region_similarity_calculator\nfrom object_detection import target_assigner\nfrom object_detection import tf_example_decoder\nimport ssd_constants\n\n\ndef get_rank_size():\n return int(os.environ['RANK_SIZE'])\n\ndef get_rank_id():\n return int(os.environ['DEVICE_ID'])\n\nclass DefaultBoxes(object):\n \"\"\"Default bounding boxes for 300x300 5 layer SSD.\n\n Default bounding boxes generation follows the order of (W, H, anchor_sizes).\n Therefore, the tensor converted from DefaultBoxes has a shape of\n [anchor_sizes, H, W, 4]. The last dimension is the box coordinates; 'ltrb'\n is [ymin, xmin, ymax, xmax] while 'xywh' is [cy, cx, h, w].\n \"\"\"\n\n def __init__(self):\n fk = ssd_constants.IMAGE_SIZE / np.array(ssd_constants.STEPS)\n\n self.default_boxes = []\n # size of feature and number of feature\n for idx, feature_size in enumerate(ssd_constants.FEATURE_SIZES):\n sk1 = ssd_constants.SCALES[idx] / ssd_constants.IMAGE_SIZE\n sk2 = ssd_constants.SCALES[idx+1] / ssd_constants.IMAGE_SIZE\n sk3 = math.sqrt(sk1*sk2)\n all_sizes = [(sk1, sk1), (sk3, sk3)]\n\n for alpha in ssd_constants.ASPECT_RATIOS[idx]:\n w, h = sk1 * math.sqrt(alpha), sk1 / math.sqrt(alpha)\n all_sizes.append((w, h))\n all_sizes.append((h, w))\n\n assert len(all_sizes) == ssd_constants.NUM_DEFAULTS[idx]\n\n for i, j in it.product(range(feature_size), repeat=2):\n for w, h in all_sizes:\n cx, cy = (j + 0.5) / fk[idx], (i + 0.5) / fk[idx]\n box = tuple(np.clip(k, 0, 1) for k in (cy, cx, h, w))\n self.default_boxes.append(box)\n\n assert len(self.default_boxes) == ssd_constants.NUM_SSD_BOXES\n\n def to_ltrb(cy, cx, h, w):\n return cy - h / 2, cx - w / 2, cy + h / 2, cx + w / 2\n\n # For IoU calculation\n self.default_boxes_ltrb = tuple(to_ltrb(*i) for i in self.default_boxes)\n\n def __call__(self, order='ltrb'):\n if order == 'ltrb': return self.default_boxes_ltrb\n if order == 'xywh': return self.default_boxes\n\n\ndef calc_iou_tensor(box1, box2):\n \"\"\" Calculation of IoU based on two boxes tensor,\n Reference to https://github.com/kuangliu/pytorch-ssd\n input:\n box1 (N, 4)\n box2 (M, 4)\n output:\n IoU (N, M)\n \"\"\"\n N = tf.shape(box1)[0]\n M = tf.shape(box2)[0]\n\n be1 = tf.tile(tf.expand_dims(box1, axis=1), (1, M, 1))\n be2 = tf.tile(tf.expand_dims(box2, axis=0), (N, 1, 1))\n\n # Left Top & Right Bottom\n lt = tf.maximum(be1[:,:,:2], be2[:,:,:2])\n\n rb = tf.minimum(be1[:,:,2:], be2[:,:,2:])\n\n delta = tf.maximum(rb - lt, 0)\n\n intersect = delta[:,:,0]*delta[:,:,1]\n\n delta1 = be1[:,:,2:] - be1[:,:,:2]\n area1 = delta1[:,:,0]*delta1[:,:,1]\n delta2 = be2[:,:,2:] - be2[:,:,:2]\n area2 = delta2[:,:,0]*delta2[:,:,1]\n\n iou = intersect/(area1 + area2 - intersect)\n return iou\n\n\ndef ssd_crop(image, boxes, classes):\n \"\"\"IoU biassed random crop.\n\n Reference: https://github.com/chauhan-utk/ssd.DomainAdaptation\n \"\"\"\n\n num_boxes = tf.shape(boxes)[0]\n\n def no_crop_check():\n return (tf.random_uniform(shape=(), minval=0, maxval=1, dtype=tf.float32)\n < ssd_constants.P_NO_CROP_PER_PASS)\n\n def no_crop_proposal():\n return (\n tf.ones((), tf.bool),\n tf.convert_to_tensor([0, 0, 1, 1], dtype=tf.float32),\n tf.ones((num_boxes,), tf.bool),\n )\n\n def crop_proposal():\n rand_vec = lambda minval, maxval: tf.random_uniform(\n shape=(ssd_constants.NUM_CROP_PASSES, 1), minval=minval, maxval=maxval,\n dtype=tf.float32)\n\n width, height = rand_vec(0.3, 1), rand_vec(0.3, 1)\n left, top = rand_vec(0, 1-width), rand_vec(0, 1-height)\n\n right = left + width\n bottom = top + height\n\n ltrb = tf.concat([left, top, right, bottom], axis=1)\n\n min_iou = tf.random_shuffle(ssd_constants.CROP_MIN_IOU_CHOICES)[0]\n ious = calc_iou_tensor(ltrb, boxes)\n\n # discard any bboxes whose center not in the cropped image\n xc, yc = [tf.tile(0.5 * (boxes[:, i + 0] + boxes[:, i + 2])[tf.newaxis, :],\n (ssd_constants.NUM_CROP_PASSES, 1)) for i in range(2)]\n\n masks = tf.reduce_all(tf.stack([\n tf.greater(xc, tf.tile(left, (1, num_boxes))),\n tf.less(xc, tf.tile(right, (1, num_boxes))),\n tf.greater(yc, tf.tile(top, (1, num_boxes))),\n tf.less(yc, tf.tile(bottom, (1, num_boxes))),\n ], axis=2), axis=2)\n\n # Checks of whether a crop is valid.\n valid_aspect = tf.logical_and(tf.less(height/width, 2),\n tf.less(width/height, 2))\n valid_ious = tf.reduce_all(tf.greater(ious, min_iou), axis=1, keepdims=True)\n valid_masks = tf.reduce_any(masks, axis=1, keepdims=True)\n\n valid_all = tf.cast(tf.reduce_all(tf.concat(\n [valid_aspect, valid_ious, valid_masks], axis=1), axis=1), tf.int32)\n\n # One indexed, as zero is needed for the case of no matches.\n index = tf.range(1, 1 + ssd_constants.NUM_CROP_PASSES, dtype=tf.int32)\n\n # Either one-hot, or zeros if there is no valid crop.\n selection = tf.equal(tf.reduce_max(index * valid_all), index)\n\n use_crop = tf.reduce_any(selection)\n output_ltrb = tf.reduce_sum(tf.multiply(ltrb, tf.tile(tf.cast(\n selection, tf.float32)[:, tf.newaxis], (1, 4))), axis=0)\n output_masks = tf.reduce_any(tf.logical_and(masks, tf.tile(\n selection[:, tf.newaxis], (1, num_boxes))), axis=0)\n\n return use_crop, output_ltrb, output_masks\n\n def proposal(*args):\n return tf.cond(\n pred=no_crop_check(),\n true_fn=no_crop_proposal,\n false_fn=crop_proposal,\n )\n\n _, crop_bounds, box_masks = tf.while_loop(\n cond=lambda x, *_: tf.logical_not(x),\n body=proposal,\n loop_vars=[tf.zeros((), tf.bool), tf.zeros((4,), tf.float32), tf.zeros((num_boxes,), tf.bool)],\n )\n\n filtered_boxes = tf.boolean_mask(boxes, box_masks, axis=0)\n\n # Clip boxes to the cropped region.\n filtered_boxes = tf.stack([\n tf.maximum(filtered_boxes[:, 0], crop_bounds[0]),\n tf.maximum(filtered_boxes[:, 1], crop_bounds[1]),\n tf.minimum(filtered_boxes[:, 2], crop_bounds[2]),\n tf.minimum(filtered_boxes[:, 3], crop_bounds[3]),\n ], axis=1)\n\n left = crop_bounds[0]\n top = crop_bounds[1]\n width = crop_bounds[2] - left\n height = crop_bounds[3] - top\n\n cropped_boxes = tf.stack([\n (filtered_boxes[:, 0] - left) / width,\n (filtered_boxes[:, 1] - top) / height,\n (filtered_boxes[:, 2] - left) / width,\n (filtered_boxes[:, 3] - top) / height,\n ], axis=1)\n\n cropped_image = tf.image.crop_and_resize(\n image=image[tf.newaxis, :, :, :],\n boxes=crop_bounds[tf.newaxis, :],\n box_ind=tf.zeros((1,), tf.int32),\n crop_size=(ssd_constants.IMAGE_SIZE, ssd_constants.IMAGE_SIZE),\n )[0, :, :, :]\n\n cropped_classes = tf.boolean_mask(classes, box_masks, axis=0)\n\n return cropped_image, cropped_boxes, cropped_classes\n\n\ndef color_jitter(image, brightness=0, contrast=0, saturation=0, hue=0):\n \"\"\"Distorts the color of the image.\n\n Args:\n image: The input image tensor.\n brightness: A float, specifying the brightness for color jitter.\n contrast: A float, specifying the contrast for color jitter.\n saturation: A float, specifying the saturation for color jitter.\n hue: A float, specifying the hue for color jitter.\n\n Returns:\n The distorted image tensor.\n \"\"\"\n with tf.name_scope('distort_color'):\n if brightness > 0:\n image = tf.image.random_brightness(image, max_delta=brightness)\n if contrast > 0:\n image = tf.image.random_contrast(\n image, lower=1-contrast, upper=1+contrast)\n if saturation > 0:\n image = tf.image.random_saturation(\n image, lower=1-saturation, upper=1+saturation)\n if hue > 0:\n image = tf.image.random_hue(image, max_delta=hue)\n return image\n\n\ndef encode_labels(gt_boxes, gt_labels):\n \"\"\"Labels anchors with ground truth inputs.\n\n Args:\n gt_boxes: A float tensor with shape [N, 4] representing groundtruth boxes.\n For each row, it stores [y0, x0, y1, x1] for four corners of a box.\n gt_labels: A integer tensor with shape [N, 1] representing groundtruth\n classes.\n Returns:\n encoded_classes: a tensor with shape [num_anchors, 1].\n encoded_boxes: a tensor with shape [num_anchors, 4].\n num_positives: scalar tensor storing number of positives in an image.\n \"\"\"\n similarity_calc = region_similarity_calculator.IouSimilarity()\n matcher = argmax_matcher.ArgMaxMatcher(\n matched_threshold=ssd_constants.MATCH_THRESHOLD,\n unmatched_threshold=ssd_constants.MATCH_THRESHOLD,\n negatives_lower_than_unmatched=True,\n force_match_for_each_row=True)\n\n box_coder = faster_rcnn_box_coder.FasterRcnnBoxCoder(\n scale_factors=ssd_constants.BOX_CODER_SCALES)\n\n default_boxes = box_list.BoxList(tf.convert_to_tensor(DefaultBoxes()('ltrb')))\n target_boxes = box_list.BoxList(gt_boxes)\n\n assigner = target_assigner.TargetAssigner(\n similarity_calc, matcher, box_coder)\n\n encoded_classes, _, encoded_boxes, _, matches = assigner.assign(\n default_boxes, target_boxes, gt_labels)\n num_matched_boxes = tf.reduce_sum(\n tf.cast(tf.not_equal(matches.match_results, -1), tf.float32))\n return encoded_classes, encoded_boxes, num_matched_boxes\n\nclass SSDInputReader(object):\n \"\"\"Input reader for dataset.\"\"\"\n\n def __init__(self,\n file_pattern,\n transpose_input=False,\n is_training=False,\n distributed_eval=False,\n count=-1):\n self._file_pattern = file_pattern\n self._transpose_input = transpose_input\n self._is_training = is_training\n self._distributed_eval = distributed_eval\n self._count = count\n\n def __call__(self, params):\n example_decoder = tf_example_decoder.TfExampleDecoder()\n\n def _parse_example(data):\n with tf.name_scope('augmentation'):\n source_id = data['source_id']\n image = data['image'] # dtype uint8\n raw_shape = tf.shape(image)\n boxes = data['groundtruth_boxes']\n classes = tf.reshape(data['groundtruth_classes'], [-1, 1])\n\n # Only 80 of the 90 COCO classes are used.\n class_map = tf.convert_to_tensor(ssd_constants.CLASS_MAP)\n classes = tf.gather(class_map, classes)\n classes = tf.cast(classes, dtype=tf.float32)\n\n if self._is_training:\n image, boxes, classes = ssd_crop(image, boxes, classes)\n # ssd_crop resizes and returns image of dtype float32 and does not\n # change its range (i.e., value in between 0--255). Divide by 255.\n # converts it to [0, 1] range. Not doing this before cropping to\n # avoid dtype cast (which incurs additional memory copy).\n image /= 255.0\n\n # random_horizontal_flip() is hard coded to flip with 50% chance.\n image, boxes = preprocessor.random_horizontal_flip(\n image=image, boxes=boxes)\n\n # TODO(shibow): Investigate the parameters for color jitter.\n image = color_jitter(\n image, brightness=0.125, contrast=0.5, saturation=0.5, hue=0.05)\n\n\n encoded_classes, encoded_boxes, num_matched_boxes = encode_labels(\n boxes, classes)\n\n # TODO(taylorrobie): Check that this cast is valid.\n encoded_classes = tf.cast(encoded_classes, tf.int32)\n\n labels = {\n ssd_constants.NUM_MATCHED_BOXES: num_matched_boxes,\n ssd_constants.BOXES: encoded_boxes,\n ssd_constants.CLASSES: tf.squeeze(encoded_classes, axis=1),\n }\n\n return image, labels\n\n else:\n image = tf.image.resize_images(\n image, size=(ssd_constants.IMAGE_SIZE, ssd_constants.IMAGE_SIZE))\n # resize_image returns image of dtype float32 and does not change its\n # range. Divide by 255 to convert image to [0, 1] range.\n image /= 255.\n\n def trim_and_pad(inp_tensor, dim_1):\n \"\"\"Limit the number of boxes, and pad if necessary.\"\"\"\n inp_tensor = inp_tensor[:ssd_constants.MAX_NUM_EVAL_BOXES]\n num_pad = ssd_constants.MAX_NUM_EVAL_BOXES - tf.shape(inp_tensor)[0]\n inp_tensor = tf.pad(inp_tensor, [[0, num_pad], [0, 0]])\n return tf.reshape(\n inp_tensor, [ssd_constants.MAX_NUM_EVAL_BOXES, dim_1])\n\n boxes, classes = trim_and_pad(boxes, 4), trim_and_pad(classes, 1)\n\n sample = {\n ssd_constants.IMAGE: image,\n ssd_constants.BOXES: boxes,\n ssd_constants.CLASSES: classes,\n ssd_constants.SOURCE_ID: tf.string_to_number(source_id, tf.int32),\n ssd_constants.RAW_SHAPE: raw_shape,\n }\n\n return sample\n\n batch_size = params['batch_size']\n dataset = tf.data.Dataset.list_files(self._file_pattern, shuffle=False)\n\n if self._is_training or self._distributed_eval:\n if get_rank_size() == 1:\n dataset = dataset.shard(1, 0)\n else:\n dataset = dataset.shard(get_rank_size(), get_rank_id())\n if self._is_training:\n dataset = dataset.shuffle( tf.to_int64(256))\n\n # Prefetch data from files.\n def _prefetch_dataset(filename):\n dataset = tf.data.TFRecordDataset(filename).prefetch(1)\n return dataset\n dataset = dataset.apply(\n tf.data.experimental.parallel_interleave(\n _prefetch_dataset, cycle_length=32, sloppy=self._is_training))\n\n # Parse the fetched records to input tensors for model function.\n dataset = dataset.map(example_decoder.decode, num_parallel_calls=256)\n\n if self._is_training:\n dataset = dataset.map(\n # pylint: disable=g-long-lambda\n lambda data: (data,\n tf.greater(tf.shape(data['groundtruth_boxes'])[0], 0)),\n num_parallel_calls=256)\n dataset = dataset.filter(lambda data, pred: pred)\n\n dataset = dataset.shuffle(64).repeat()\n\n dataset = dataset.map(lambda data, pred: data) # use the first value\n dataset = dataset.map(_parse_example, num_parallel_calls=256)\n dataset = dataset.batch(batch_size=batch_size, drop_remainder=True)\n else:\n dataset = dataset.prefetch(batch_size * 256)\n dataset = dataset.map(_parse_example, num_parallel_calls=256)\n dataset = dataset.batch(batch_size=batch_size, drop_remainder=True)\n\n dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)\n options = tf.data.Options()\n options.experimental_threading.max_intra_op_parallelism = 1\n options.experimental_threading.private_threadpool_size = 32\n dataset = dataset.with_options(options)\n\n return dataset\n",
"# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n# Copyright 2020 Huawei Technologies Co., Ltd\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 time\nimport numpy as np\nimport tensorflow as tf\nimport random\nfrom tensorflow.contrib import slim\n\nfrom npu_bridge.estimator import npu_ops\nfrom tensorflow.core.protobuf.rewriter_config_pb2 import RewriterConfig\n\ntf.app.flags.DEFINE_integer('input_size', 512, '')\ntf.app.flags.DEFINE_integer('batch_size_per_gpu', 14, '')\ntf.app.flags.DEFINE_integer('num_readers', 16, '')\ntf.app.flags.DEFINE_float('learning_rate', 0.0001, '')\ntf.app.flags.DEFINE_integer('max_steps', 100000, '')\ntf.app.flags.DEFINE_integer('loss_scale', 1024, '')\ntf.app.flags.DEFINE_float('moving_average_decay', 0.997, '')\ntf.app.flags.DEFINE_string('gpu_list', '1', '')\ntf.app.flags.DEFINE_string('checkpoint_path', '/tmp/east_resnet_v1_50_rbox/', '')\ntf.app.flags.DEFINE_boolean('restore', False, 'whether to resotre from checkpoint')\ntf.app.flags.DEFINE_integer('save_checkpoint_steps', 1000, '')\ntf.app.flags.DEFINE_integer('save_summary_steps', 100, '')\ntf.app.flags.DEFINE_string('pretrained_model_path', None, '')\ntf.app.flags.DEFINE_boolean('allow_mix_precision', False, 'whether to allow mix precision')\ntf.app.flags.DEFINE_boolean('auto_tune', False, 'whether to autotune')\ntf.app.flags.DEFINE_boolean('use_processed_data', False, 'whether to use processed data')\ntf.app.flags.DEFINE_string('processed_data', './processed_dataset/', 'where to save preprocessed datasets')\n\nimport model\nimport icdar\n\nFLAGS = tf.app.flags.FLAGS\n\ngpus = list(range(len(FLAGS.gpu_list.split(','))))\n\n\ndef tower_loss(images, score_maps, geo_maps, training_masks, reuse_variables=None):\n # Build inference graph\n with tf.variable_scope(tf.get_variable_scope(), reuse=reuse_variables):\n f_score, f_geometry = model.model(images, is_training=True)\n\n model_loss = model.loss(score_maps, f_score,\n geo_maps, f_geometry,\n training_masks)\n total_loss = tf.add_n([model_loss] + tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n\n # add summary\n if reuse_variables is None:\n tf.summary.image('input', images)\n tf.summary.image('score_map', score_maps)\n tf.summary.image('score_map_pred', f_score * 255)\n tf.summary.image('geo_map_0', geo_maps[:, :, :, 0:1])\n tf.summary.image('geo_map_0_pred', f_geometry[:, :, :, 0:1])\n tf.summary.image('training_masks', training_masks)\n tf.summary.scalar('model_loss', model_loss)\n tf.summary.scalar('total_loss', total_loss)\n\n return total_loss, model_loss\n\n\ndef average_gradients(tower_grads):\n average_grads = []\n for grad_and_vars in zip(*tower_grads):\n grads = []\n for g, _ in grad_and_vars:\n expanded_g = tf.expand_dims(g, 0)\n grads.append(expanded_g)\n\n grad = tf.concat(grads, 0)\n grad = tf.reduce_mean(grad, 0)\n\n v = grad_and_vars[0][1]\n grad_and_var = (grad, v)\n average_grads.append(grad_and_var)\n\n return average_grads\n\nclass MixedPrecisionOptimizer(tf.train.Optimizer):\n \"\"\"An optimizer that updates trainable variables in fp32.\"\"\"\n\n def __init__(self, optimizer,\n scale=None,\n name=\"MixedPrecisionOptimizer\",\n use_locking=False):\n super(MixedPrecisionOptimizer, self).__init__(\n name=name, use_locking=use_locking)\n self._optimizer = optimizer\n self._scale = float(scale) if scale is not None else 1.0\n\n def compute_gradients(self, loss, var_list=None, *args, **kwargs):\n if var_list is None:\n var_list = (\n tf.trainable_variables() +\n tf.get_collection(tf.GraphKeys.TRAINABLE_RESOURCE_VARIABLES))\n\n replaced_list = var_list\n\n if self._scale != 1.0:\n loss = tf.scalar_mul(self._scale, loss)\n\n gradvar = self._optimizer.compute_gradients(loss, replaced_list, *args, **kwargs)\n\n final_gradvar = []\n for orig_var, (grad, var) in zip(var_list, gradvar):\n if var is not orig_var:\n grad = tf.cast(grad, orig_var.dtype)\n if self._scale != 1.0:\n grad = tf.scalar_mul(1. / self._scale, grad)\n final_gradvar.append((grad, orig_var))\n\n return final_gradvar\n\n def apply_gradients(self, *args, **kwargs):\n return self._optimizer.apply_gradients(*args, **kwargs)\n\ndef main(argv=None):\n start1 = time.time()\n import os\n os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu_list\n if not tf.gfile.Exists(FLAGS.checkpoint_path):\n tf.gfile.MkDir(FLAGS.checkpoint_path)\n else:\n if not FLAGS.restore:\n tf.gfile.DeleteRecursively(FLAGS.checkpoint_path)\n tf.gfile.MkDir(FLAGS.checkpoint_path)\n\n input_images = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='input_images')\n input_score_maps = tf.placeholder(tf.float32, shape=[None, None, None, 1], name='input_score_maps')\n if FLAGS.geometry == 'RBOX':\n input_geo_maps = tf.placeholder(tf.float32, shape=[None, None, None, 5], name='input_geo_maps')\n else:\n input_geo_maps = tf.placeholder(tf.float32, shape=[None, None, None, 8], name='input_geo_maps')\n input_training_masks = tf.placeholder(tf.float32, shape=[None, None, None, 1], name='input_training_masks')\n\n global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False)\n learning_rate = tf.train.exponential_decay(FLAGS.learning_rate, global_step, decay_steps=10000, decay_rate=0.94, staircase=True)\n # add summary\n tf.summary.scalar('learning_rate', learning_rate)\n opt = tf.train.AdamOptimizer(learning_rate)\n opt = MixedPrecisionOptimizer(opt, scale=FLAGS.loss_scale)\n from npu_bridge.estimator.npu.npu_optimizer import NPUDistributedOptimizer\n opt = NPUDistributedOptimizer(opt)\n # split\n input_images_split = tf.split(input_images, len(gpus))\n input_score_maps_split = tf.split(input_score_maps, len(gpus))\n input_geo_maps_split = tf.split(input_geo_maps, len(gpus))\n input_training_masks_split = tf.split(input_training_masks, len(gpus))\n\n tower_grads = []\n reuse_variables = None\n for i, gpu_id in enumerate(gpus):\n #with tf.device('/gpu:%d' % gpu_id):\n with tf.name_scope('model_%d' % gpu_id) as scope:\n iis = input_images_split[i]\n isms = input_score_maps_split[i]\n igms = input_geo_maps_split[i]\n itms = input_training_masks_split[i]\n total_loss, model_loss = tower_loss(iis, isms, igms, itms, reuse_variables)\n batch_norm_updates_op = tf.group(*tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope))\n reuse_variables = True\n\n grads = opt.compute_gradients(total_loss)\n tower_grads.append(grads)\n\n grads = average_gradients(tower_grads)\n apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)\n\n summary_op = tf.summary.merge_all()\n # save moving average\n variable_averages = tf.train.ExponentialMovingAverage(\n FLAGS.moving_average_decay, global_step)\n variables_averages_op = variable_averages.apply(tf.trainable_variables())\n # batch norm updates\n with tf.control_dependencies([variables_averages_op, apply_gradient_op, batch_norm_updates_op]):\n train_op = tf.no_op(name='train_op')\n\n saver = tf.train.Saver(tf.global_variables())\n summary_writer = tf.summary.FileWriter(FLAGS.checkpoint_path, tf.get_default_graph())\n\n init = tf.global_variables_initializer()\n\n if FLAGS.pretrained_model_path is not None:\n variable_restore_op = slim.assign_from_checkpoint_fn(FLAGS.pretrained_model_path, slim.get_trainable_variables(),\n ignore_missing_vars=True)\n\n config = tf.ConfigProto()\n custom_op = config.graph_options.rewrite_options.custom_optimizers.add()\n custom_op.name = \"NpuOptimizer\"\n custom_op.parameter_map[\"use_off_line\"].b = True # 在昇腾AI处理器执行训练\n config.graph_options.rewrite_options.remapping = RewriterConfig.OFF # 关闭remap开关\n if FLAGS.allow_mix_precision:\n custom_op.parameter_map[\"precision_mode\"].s = tf.compat.as_bytes(\"allow_mix_precision\")\n if FLAGS.auto_tune:\n custom_op.parameter_map[\"auto_tune_mode\"].s = tf.compat.as_bytes(\"RL,GA\")\n \n with tf.Session(config=config) as sess:\n if FLAGS.restore:\n print('continue training from previous checkpoint')\n ckpt = tf.train.latest_checkpoint(FLAGS.checkpoint_path)\n saver.restore(sess, ckpt)\n else:\n sess.run(init)\n if FLAGS.pretrained_model_path is not None:\n variable_restore_op(sess)\n\n data_generator = icdar.get_batch(num_workers=FLAGS.num_readers,\n input_size=FLAGS.input_size,\n batch_size=FLAGS.batch_size_per_gpu * len(gpus))\n\n start = time.time()\n avg_time_per_step1 = 0\n performs = []\n for step in range(FLAGS.max_steps):\n if FLAGS.use_processed_data:\n index = random.randint(0,1000-1)\n images = np.fromfile(os.path.join(FLAGS.processed_data,'input_images_{}.bin'.format(index)),dtype='float32').reshape(FLAGS.batch_size_per_gpu,FLAGS.input_size,FLAGS.input_size,3)\n score_maps = np.fromfile(os.path.join(FLAGS.processed_data,'input_score_maps_{}.bin'.format(index)),dtype='float32').reshape(FLAGS.batch_size_per_gpu,128,128,1)\n geo_maps = np.fromfile(os.path.join(FLAGS.processed_data,'input_geo_maps_{}.bin'.format(index)),dtype='float32').reshape(FLAGS.batch_size_per_gpu,128,128,5)\n training_masks = np.fromfile(os.path.join(FLAGS.processed_data, 'input_training_masks_{}.bin'.format(index)),dtype='float32').reshape(FLAGS.batch_size_per_gpu, 128, 128, 1)\n else:\n data = next(data_generator)\n images = data[0]\n score_maps = data[2]\n geo_maps = data[3]\n training_masks = data[4]\n ml, tl, _ = sess.run([model_loss, total_loss, train_op], feed_dict={input_images: images,\n input_score_maps: score_maps,\n input_geo_maps: geo_maps,\n input_training_masks: training_masks})\n if np.isnan(tl):\n print('Loss diverged, stop training')\n break\n\n if step % 10 == 0:\n avg_time_per_step = (time.time() - start)/10\n avg_time_per_step1 += (time.time() - start)/FLAGS.max_steps\n avg_examples_per_second = (10 * FLAGS.batch_size_per_gpu * len(gpus))/(time.time() - start)\n performs.append(float(avg_examples_per_second))\n start = time.time()\n print('Step {:06d}, model loss {:.4f}, total loss {:.4f}, {:.2f} seconds/step, {:.2f} examples/second'.format(\n step, ml, tl, avg_time_per_step, avg_examples_per_second))\n\n if step % FLAGS.save_checkpoint_steps == 0:\n saver.save(sess, FLAGS.checkpoint_path + 'model.ckpt', global_step=global_step)\n\n if step % FLAGS.save_summary_steps == 0:\n _, tl, summary_str = sess.run([train_op, total_loss, summary_op], feed_dict={input_images: images,\n input_score_maps: score_maps,\n input_geo_maps: geo_maps,\n input_training_masks: training_masks})\n summary_writer.add_summary(summary_str, global_step=step)\n print(\"Final Train Accuracy\", tl)\n E2Etime = time.time() - start1\n print(\"E2E Training Duration sec\", E2Etime)\n print(\"avg time per step\", avg_time_per_step1)\n print(\"FPS {:.2f}\".format(sum(performs)/len(performs)))\n\nif __name__ == '__main__':\n tf.app.run()\n",
"# Copyright 2020 Huawei Technologies Co., Ltd\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\"\"\"Bert model.\"\"\"\nimport math\nimport copy\nimport numpy as np\nimport mindspore.common.dtype as mstype\nimport mindspore.nn as nn\nimport mindspore.ops.functional as F\nfrom mindspore.common.initializer import TruncatedNormal, initializer\nfrom mindspore.ops import operations as P\nfrom mindspore.ops import composite as C\nfrom mindspore.common.tensor import Tensor\nfrom mindspore.common.parameter import Parameter\nfrom mindspore import context\n\n\nclass BertConfig:\n \"\"\"\n Configuration for `BertModel`.\n\n Args:\n seq_length (int): Length of input sequence. Default: 128.\n vocab_size (int): The shape of each embedding vector. Default: 32000.\n hidden_size (int): Size of the bert encoder layers. Default: 768.\n num_hidden_layers (int): Number of hidden layers in the BertTransformer encoder\n cell. Default: 12.\n num_attention_heads (int): Number of attention heads in the BertTransformer\n encoder cell. Default: 12.\n intermediate_size (int): Size of intermediate layer in the BertTransformer\n encoder cell. Default: 3072.\n hidden_act (str): Activation function used in the BertTransformer encoder\n cell. Default: \"gelu\".\n hidden_dropout_prob (float): The dropout probability for BertOutput. Default: 0.1.\n attention_probs_dropout_prob (float): The dropout probability for\n BertAttention. Default: 0.1.\n max_position_embeddings (int): Maximum length of sequences used in this\n model. Default: 512.\n type_vocab_size (int): Size of token type vocab. Default: 16.\n initializer_range (float): Initialization value of TruncatedNormal. Default: 0.02.\n use_relative_positions (bool): Specifies whether to use relative positions. Default: False.\n dtype (:class:`mindspore.dtype`): Data type of the input. Default: mstype.float32.\n compute_type (:class:`mindspore.dtype`): Compute type in BertTransformer. Default: mstype.float32.\n \"\"\"\n\n def __init__(self,\n seq_length=128,\n vocab_size=32000,\n hidden_size=768,\n num_hidden_layers=12,\n num_attention_heads=12,\n intermediate_size=3072,\n hidden_act=\"gelu\",\n hidden_dropout_prob=0.1,\n attention_probs_dropout_prob=0.1,\n max_position_embeddings=512,\n type_vocab_size=16,\n initializer_range=0.02,\n use_relative_positions=False,\n dtype=mstype.float32,\n compute_type=mstype.float32):\n self.seq_length = seq_length\n self.vocab_size = vocab_size\n self.hidden_size = hidden_size\n self.num_hidden_layers = num_hidden_layers\n self.num_attention_heads = num_attention_heads\n self.hidden_act = hidden_act\n self.intermediate_size = intermediate_size\n self.hidden_dropout_prob = hidden_dropout_prob\n self.attention_probs_dropout_prob = attention_probs_dropout_prob\n self.max_position_embeddings = max_position_embeddings\n self.type_vocab_size = type_vocab_size\n self.initializer_range = initializer_range\n self.use_relative_positions = use_relative_positions\n self.dtype = dtype\n self.compute_type = compute_type\n\n\nclass EmbeddingLookup(nn.Cell):\n \"\"\"\n A embeddings lookup table with a fixed dictionary and size.\n\n Args:\n vocab_size (int): Size of the dictionary of embeddings.\n embedding_size (int): The size of each embedding vector.\n embedding_shape (list): [batch_size, seq_length, embedding_size], the shape of\n each embedding vector.\n use_one_hot_embeddings (bool): Specifies whether to use one hot encoding form. Default: False.\n initializer_range (float): Initialization value of TruncatedNormal. Default: 0.02.\n \"\"\"\n\n def __init__(self,\n vocab_size,\n embedding_size,\n embedding_shape,\n use_one_hot_embeddings=False,\n initializer_range=0.02):\n super(EmbeddingLookup, self).__init__()\n self.vocab_size = vocab_size\n self.use_one_hot_embeddings = use_one_hot_embeddings\n self.embedding_table = Parameter(initializer\n (TruncatedNormal(initializer_range),\n [vocab_size, embedding_size]),\n name='embedding_table')\n self.expand = P.ExpandDims()\n self.shape_flat = (-1,)\n self.gather = P.GatherV2()\n self.one_hot = P.OneHot()\n self.on_value = Tensor(1.0, mstype.float32)\n self.off_value = Tensor(0.0, mstype.float32)\n self.array_mul = P.MatMul()\n self.reshape = P.Reshape()\n self.shape = tuple(embedding_shape)\n\n def construct(self, input_ids):\n \"\"\"embedding lookup\"\"\"\n extended_ids = self.expand(input_ids, -1)\n flat_ids = self.reshape(extended_ids, self.shape_flat)\n if self.use_one_hot_embeddings:\n one_hot_ids = self.one_hot(\n flat_ids,\n self.vocab_size,\n self.on_value,\n self.off_value)\n output_for_reshape = self.array_mul(\n one_hot_ids, self.embedding_table)\n else:\n output_for_reshape = self.gather(self.embedding_table, flat_ids, 0)\n output = self.reshape(output_for_reshape, self.shape)\n return output, self.embedding_table\n\n\nclass EmbeddingPostprocessor(nn.Cell):\n \"\"\"\n Postprocessors apply positional and token type embeddings to word embeddings.\n\n Args:\n embedding_size (int): The size of each embedding vector.\n embedding_shape (list): [batch_size, seq_length, embedding_size], the shape of\n each embedding vector.\n use_token_type (bool): Specifies whether to use token type embeddings. Default: False.\n token_type_vocab_size (int): Size of token type vocab. Default: 16.\n use_one_hot_embeddings (bool): Specifies whether to use one hot encoding form. Default: False.\n initializer_range (float): Initialization value of TruncatedNormal. Default: 0.02.\n max_position_embeddings (int): Maximum length of sequences used in this\n model. Default: 512.\n dropout_prob (float): The dropout probability. Default: 0.1.\n \"\"\"\n\n def __init__(self,\n use_relative_positions,\n embedding_size,\n embedding_shape,\n use_token_type=False,\n token_type_vocab_size=16,\n use_one_hot_embeddings=False,\n initializer_range=0.02,\n max_position_embeddings=512,\n dropout_prob=0.1):\n super(EmbeddingPostprocessor, self).__init__()\n self.use_token_type = use_token_type\n self.token_type_vocab_size = token_type_vocab_size\n self.use_one_hot_embeddings = use_one_hot_embeddings\n self.max_position_embeddings = max_position_embeddings\n self.embedding_table = Parameter(initializer\n (TruncatedNormal(initializer_range),\n [token_type_vocab_size,\n embedding_size]),\n name='embedding_table')\n self.shape_flat = (-1,)\n self.one_hot = P.OneHot()\n self.on_value = Tensor(1.0, mstype.float32)\n self.off_value = Tensor(0.1, mstype.float32)\n self.array_mul = P.MatMul()\n self.reshape = P.Reshape()\n self.shape = tuple(embedding_shape)\n self.layernorm = nn.LayerNorm((embedding_size,))\n self.dropout = nn.Dropout(1 - dropout_prob)\n self.gather = P.GatherV2()\n self.use_relative_positions = use_relative_positions\n self.slice = P.StridedSlice()\n self.full_position_embeddings = Parameter(initializer\n (TruncatedNormal(initializer_range),\n [max_position_embeddings,\n embedding_size]),\n name='full_position_embeddings')\n\n def construct(self, token_type_ids, word_embeddings):\n \"\"\"embedding postprocessor\"\"\"\n output = word_embeddings\n if self.use_token_type:\n flat_ids = self.reshape(token_type_ids, self.shape_flat)\n if self.use_one_hot_embeddings:\n one_hot_ids = self.one_hot(flat_ids,\n self.token_type_vocab_size, self.on_value, self.off_value)\n token_type_embeddings = self.array_mul(one_hot_ids,\n self.embedding_table)\n else:\n token_type_embeddings = self.gather(\n self.embedding_table, flat_ids, 0)\n token_type_embeddings = self.reshape(\n token_type_embeddings, self.shape)\n output += token_type_embeddings\n if not self.use_relative_positions:\n _, seq, width = self.shape\n position_embeddings = self.slice(\n self.full_position_embeddings, (0, 0), (seq, width), (1, 1))\n position_embeddings = self.reshape(\n position_embeddings, (1, seq, width))\n output += position_embeddings\n output = self.layernorm(output)\n output = self.dropout(output)\n return output\n\n\nclass BertOutput(nn.Cell):\n \"\"\"\n Apply a linear computation to hidden status and a residual computation to input.\n\n Args:\n in_channels (int): Input channels.\n out_channels (int): Output channels.\n initializer_range (float): Initialization value of TruncatedNormal. Default: 0.02.\n dropout_prob (float): The dropout probability. Default: 0.1.\n compute_type (:class:`mindspore.dtype`): Compute type in BertTransformer. Default: mstype.float32.\n \"\"\"\n\n def __init__(self,\n in_channels,\n out_channels,\n initializer_range=0.02,\n dropout_prob=0.1,\n compute_type=mstype.float32):\n super(BertOutput, self).__init__()\n self.dense = nn.Dense(in_channels, out_channels,\n weight_init=TruncatedNormal(initializer_range)).to_float(compute_type)\n self.dropout = nn.Dropout(1 - dropout_prob)\n self.add = P.TensorAdd()\n self.is_gpu = context.get_context('device_target') == \"GPU\"\n if self.is_gpu:\n self.layernorm = nn.LayerNorm(\n (out_channels,)).to_float(\n mstype.float32)\n self.compute_type = compute_type\n else:\n self.layernorm = nn.LayerNorm(\n (out_channels,)).to_float(compute_type)\n\n self.cast = P.Cast()\n\n def construct(self, hidden_status, input_tensor):\n \"\"\"bert output\"\"\"\n output = self.dense(hidden_status)\n output = self.dropout(output)\n output = self.add(input_tensor, output)\n output = self.layernorm(output)\n if self.is_gpu:\n output = self.cast(output, self.compute_type)\n return output\n\n\nclass RelaPosMatrixGenerator(nn.Cell):\n \"\"\"\n Generates matrix of relative positions between inputs.\n\n Args:\n length (int): Length of one dim for the matrix to be generated.\n max_relative_position (int): Max value of relative position.\n \"\"\"\n\n def __init__(self, length, max_relative_position):\n super(RelaPosMatrixGenerator, self).__init__()\n self._length = length\n self._max_relative_position = Tensor(\n max_relative_position, dtype=mstype.int32)\n self._min_relative_position = Tensor(\n -max_relative_position, dtype=mstype.int32)\n self.range_length = -length + 1\n self.tile = P.Tile()\n self.range_mat = P.Reshape()\n self.sub = P.Sub()\n self.expanddims = P.ExpandDims()\n self.cast = P.Cast()\n\n def construct(self):\n \"\"\"position matrix generator\"\"\"\n range_vec_row_out = self.cast(\n F.tuple_to_array(\n F.make_range(\n self._length)),\n mstype.int32)\n range_vec_col_out = self.range_mat(\n range_vec_row_out, (self._length, -1))\n tile_row_out = self.tile(range_vec_row_out, (self._length,))\n tile_col_out = self.tile(range_vec_col_out, (1, self._length))\n range_mat_out = self.range_mat(\n tile_row_out, (self._length, self._length))\n transpose_out = self.range_mat(\n tile_col_out, (self._length, self._length))\n distance_mat = self.sub(range_mat_out, transpose_out)\n distance_mat_clipped = C.clip_by_value(distance_mat,\n self._min_relative_position,\n self._max_relative_position)\n # Shift values to be >=0. Each integer still uniquely identifies a\n # relative position difference.\n final_mat = distance_mat_clipped + self._max_relative_position\n return final_mat\n\n\nclass RelaPosEmbeddingsGenerator(nn.Cell):\n \"\"\"\n Generates tensor of size [length, length, depth].\n\n Args:\n length (int): Length of one dim for the matrix to be generated.\n depth (int): Size of each attention head.\n max_relative_position (int): Maxmum value of relative position.\n initializer_range (float): Initialization value of TruncatedNormal.\n use_one_hot_embeddings (bool): Specifies whether to use one hot encoding form. Default: False.\n \"\"\"\n\n def __init__(self,\n length,\n depth,\n max_relative_position,\n initializer_range,\n use_one_hot_embeddings=False):\n super(RelaPosEmbeddingsGenerator, self).__init__()\n self.depth = depth\n self.vocab_size = max_relative_position * 2 + 1\n self.use_one_hot_embeddings = use_one_hot_embeddings\n self.embeddings_table = Parameter(\n initializer(TruncatedNormal(initializer_range),\n [self.vocab_size, self.depth]),\n name='embeddings_for_position')\n self.relative_positions_matrix = RelaPosMatrixGenerator(length=length,\n max_relative_position=max_relative_position)\n self.reshape = P.Reshape()\n self.one_hot = P.OneHot()\n self.on_value = Tensor(1.0, mstype.float32)\n self.off_value = Tensor(0.0, mstype.float32)\n self.shape = P.Shape()\n self.gather = P.GatherV2() # index_select\n self.matmul = P.BatchMatMul()\n\n def construct(self):\n \"\"\"position embedding generation\"\"\"\n relative_positions_matrix_out = self.relative_positions_matrix()\n # Generate embedding for each relative position of dimension depth.\n if self.use_one_hot_embeddings:\n flat_relative_positions_matrix = self.reshape(\n relative_positions_matrix_out, (-1,))\n one_hot_relative_positions_matrix = self.one_hot(\n flat_relative_positions_matrix, self.vocab_size, self.on_value, self.off_value)\n embeddings = self.matmul(\n one_hot_relative_positions_matrix,\n self.embeddings_table)\n my_shape = self.shape(\n relative_positions_matrix_out) + (self.depth,)\n embeddings = self.reshape(embeddings, my_shape)\n else:\n embeddings = self.gather(self.embeddings_table,\n relative_positions_matrix_out, 0)\n return embeddings\n\n\nclass SaturateCast(nn.Cell):\n \"\"\"\n Performs a safe saturating cast. This operation applies proper clamping before casting to prevent\n the danger that the value will overflow or underflow.\n\n Args:\n src_type (:class:`mindspore.dtype`): The type of the elements of the input tensor. Default: mstype.float32.\n dst_type (:class:`mindspore.dtype`): The type of the elements of the output tensor. Default: mstype.float32.\n \"\"\"\n\n def __init__(self, src_type=mstype.float32, dst_type=mstype.float32):\n super(SaturateCast, self).__init__()\n np_type = mstype.dtype_to_nptype(dst_type)\n min_type = np.finfo(np_type).min\n max_type = np.finfo(np_type).max\n self.tensor_min_type = Tensor([min_type], dtype=src_type)\n self.tensor_max_type = Tensor([max_type], dtype=src_type)\n self.min_op = P.Minimum()\n self.max_op = P.Maximum()\n self.cast = P.Cast()\n self.dst_type = dst_type\n\n def construct(self, x):\n \"\"\"saturate cast\"\"\"\n out = self.max_op(x, self.tensor_min_type)\n out = self.min_op(out, self.tensor_max_type)\n return self.cast(out, self.dst_type)\n\n\nclass BertAttention(nn.Cell):\n \"\"\"\n Apply multi-headed attention from \"from_tensor\" to \"to_tensor\".\n\n Args:\n from_tensor_width (int): Size of last dim of from_tensor.\n to_tensor_width (int): Size of last dim of to_tensor.\n from_seq_length (int): Length of from_tensor sequence.\n to_seq_length (int): Length of to_tensor sequence.\n num_attention_heads (int): Number of attention heads. Default: 1.\n size_per_head (int): Size of each attention head. Default: 512.\n query_act (str): Activation function for the query transform. Default: None.\n key_act (str): Activation function for the key transform. Default: None.\n value_act (str): Activation function for the value transform. Default: None.\n has_attention_mask (bool): Specifies whether to use attention mask. Default: False.\n attention_probs_dropout_prob (float): The dropout probability for\n BertAttention. Default: 0.0.\n use_one_hot_embeddings (bool): Specifies whether to use one hot encoding form. Default: False.\n initializer_range (float): Initialization value of TruncatedNormal. Default: 0.02.\n do_return_2d_tensor (bool): True for return 2d tensor. False for return 3d\n tensor. Default: False.\n use_relative_positions (bool): Specifies whether to use relative positions. Default: False.\n compute_type (:class:`mindspore.dtype`): Compute type in BertAttention. Default: mstype.float32.\n \"\"\"\n\n def __init__(self,\n from_tensor_width,\n to_tensor_width,\n from_seq_length,\n to_seq_length,\n num_attention_heads=1,\n size_per_head=512,\n query_act=None,\n key_act=None,\n value_act=None,\n has_attention_mask=False,\n attention_probs_dropout_prob=0.0,\n use_one_hot_embeddings=False,\n initializer_range=0.02,\n do_return_2d_tensor=False,\n use_relative_positions=False,\n compute_type=mstype.float32):\n super(BertAttention, self).__init__()\n self.from_seq_length = from_seq_length\n self.to_seq_length = to_seq_length\n self.num_attention_heads = num_attention_heads\n self.size_per_head = size_per_head\n self.has_attention_mask = has_attention_mask\n self.use_relative_positions = use_relative_positions\n self.scores_mul = Tensor(\n [1.0 / math.sqrt(float(self.size_per_head))], dtype=compute_type)\n self.reshape = P.Reshape()\n self.shape_from_2d = (-1, from_tensor_width)\n self.shape_to_2d = (-1, to_tensor_width)\n weight = TruncatedNormal(initializer_range)\n units = num_attention_heads * size_per_head\n self.query_layer = nn.Dense(from_tensor_width,\n units,\n activation=query_act,\n weight_init=weight).to_float(compute_type)\n self.key_layer = nn.Dense(to_tensor_width,\n units,\n activation=key_act,\n weight_init=weight).to_float(compute_type)\n self.value_layer = nn.Dense(to_tensor_width,\n units,\n activation=value_act,\n weight_init=weight).to_float(compute_type)\n self.shape_from = (-1,\n from_seq_length,\n num_attention_heads,\n size_per_head)\n self.shape_to = (-1, to_seq_length, num_attention_heads, size_per_head)\n self.matmul_trans_b = P.BatchMatMul(transpose_b=True)\n self.multiply = P.Mul()\n self.transpose = P.Transpose()\n self.trans_shape = (0, 2, 1, 3)\n self.trans_shape_relative = (2, 0, 1, 3)\n self.trans_shape_position = (1, 2, 0, 3)\n self.multiply_data = Tensor([-10000.0, ], dtype=compute_type)\n self.matmul = P.BatchMatMul()\n self.softmax = nn.Softmax()\n self.dropout = nn.Dropout(1 - attention_probs_dropout_prob)\n if self.has_attention_mask:\n self.expand_dims = P.ExpandDims()\n self.sub = P.Sub()\n self.add = P.TensorAdd()\n self.cast = P.Cast()\n self.get_dtype = P.DType()\n if do_return_2d_tensor:\n self.shape_return = (-1, num_attention_heads * size_per_head)\n else:\n self.shape_return = (-1, from_seq_length,\n num_attention_heads * size_per_head)\n self.cast_compute_type = SaturateCast(dst_type=compute_type)\n if self.use_relative_positions:\n self._generate_relative_positions_embeddings = \\\n RelaPosEmbeddingsGenerator(length=to_seq_length,\n depth=size_per_head,\n max_relative_position=16,\n initializer_range=initializer_range,\n use_one_hot_embeddings=use_one_hot_embeddings)\n\n def construct(self, from_tensor, to_tensor, attention_mask):\n \"\"\"bert attention\"\"\"\n # reshape 2d/3d input tensors to 2d\n from_tensor_2d = self.reshape(from_tensor, self.shape_from_2d)\n to_tensor_2d = self.reshape(to_tensor, self.shape_to_2d)\n query_out = self.query_layer(from_tensor_2d)\n key_out = self.key_layer(to_tensor_2d)\n value_out = self.value_layer(to_tensor_2d)\n query_layer = self.reshape(query_out, self.shape_from)\n query_layer = self.transpose(query_layer, self.trans_shape)\n key_layer = self.reshape(key_out, self.shape_to)\n key_layer = self.transpose(key_layer, self.trans_shape)\n attention_scores = self.matmul_trans_b(query_layer, key_layer)\n # use_relative_position, supplementary logic\n if self.use_relative_positions:\n # relations_keys is [F|T, F|T, H]\n relations_keys = self._generate_relative_positions_embeddings()\n relations_keys = self.cast_compute_type(relations_keys)\n # query_layer_t is [F, B, N, H]\n query_layer_t = self.transpose(\n query_layer, self.trans_shape_relative)\n # query_layer_r is [F, B * N, H]\n query_layer_r = self.reshape(query_layer_t,\n (self.from_seq_length,\n -1,\n self.size_per_head))\n # key_position_scores is [F, B * N, F|T]\n key_position_scores = self.matmul_trans_b(query_layer_r,\n relations_keys)\n # key_position_scores_r is [F, B, N, F|T]\n key_position_scores_r = self.reshape(key_position_scores,\n (self.from_seq_length,\n -1,\n self.num_attention_heads,\n self.from_seq_length))\n # key_position_scores_r_t is [B, N, F, F|T]\n key_position_scores_r_t = self.transpose(key_position_scores_r,\n self.trans_shape_position)\n attention_scores = attention_scores + key_position_scores_r_t\n attention_scores = self.multiply(self.scores_mul, attention_scores)\n if self.has_attention_mask:\n attention_mask = self.expand_dims(attention_mask, 1)\n multiply_out = self.sub(self.cast(F.tuple_to_array((1.0,)), self.get_dtype(attention_scores)),\n self.cast(attention_mask, self.get_dtype(attention_scores)))\n adder = self.multiply(multiply_out, self.multiply_data)\n attention_scores = self.add(adder, attention_scores)\n attention_probs = self.softmax(attention_scores)\n attention_probs = self.dropout(attention_probs)\n value_layer = self.reshape(value_out, self.shape_to)\n value_layer = self.transpose(value_layer, self.trans_shape)\n context_layer = self.matmul(attention_probs, value_layer)\n # use_relative_position, supplementary logic\n if self.use_relative_positions:\n # relations_values is [F|T, F|T, H]\n relations_values = self._generate_relative_positions_embeddings()\n relations_values = self.cast_compute_type(relations_values)\n # attention_probs_t is [F, B, N, T]\n attention_probs_t = self.transpose(\n attention_probs, self.trans_shape_relative)\n # attention_probs_r is [F, B * N, T]\n attention_probs_r = self.reshape(\n attention_probs_t,\n (self.from_seq_length,\n -1,\n self.to_seq_length))\n # value_position_scores is [F, B * N, H]\n value_position_scores = self.matmul(attention_probs_r,\n relations_values)\n # value_position_scores_r is [F, B, N, H]\n value_position_scores_r = self.reshape(value_position_scores,\n (self.from_seq_length,\n -1,\n self.num_attention_heads,\n self.size_per_head))\n # value_position_scores_r_t is [B, N, F, H]\n value_position_scores_r_t = self.transpose(value_position_scores_r,\n self.trans_shape_position)\n context_layer = context_layer + value_position_scores_r_t\n context_layer = self.transpose(context_layer, self.trans_shape)\n context_layer = self.reshape(context_layer, self.shape_return)\n return context_layer, attention_scores\n\n\nclass BertSelfAttention(nn.Cell):\n \"\"\"\n Apply self-attention.\n\n Args:\n seq_length (int): Length of input sequence.\n hidden_size (int): Size of the bert encoder layers.\n num_attention_heads (int): Number of attention heads. Default: 12.\n attention_probs_dropout_prob (float): The dropout probability for\n BertAttention. Default: 0.1.\n use_one_hot_embeddings (bool): Specifies whether to use one_hot encoding form. Default: False.\n initializer_range (float): Initialization value of TruncatedNormal. Default: 0.02.\n hidden_dropout_prob (float): The dropout probability for BertOutput. Default: 0.1.\n use_relative_positions (bool): Specifies whether to use relative positions. Default: False.\n compute_type (:class:`mindspore.dtype`): Compute type in BertSelfAttention. Default: mstype.float32.\n \"\"\"\n\n def __init__(self,\n seq_length,\n hidden_size,\n num_attention_heads=12,\n attention_probs_dropout_prob=0.1,\n use_one_hot_embeddings=False,\n initializer_range=0.02,\n hidden_dropout_prob=0.1,\n use_relative_positions=False,\n compute_type=mstype.float32):\n super(BertSelfAttention, self).__init__()\n if hidden_size % num_attention_heads != 0:\n raise ValueError(\"The hidden size (%d) is not a multiple of the number \"\n \"of attention heads (%d)\" % (hidden_size, num_attention_heads))\n self.size_per_head = int(hidden_size / num_attention_heads)\n self.attention = BertAttention(\n from_tensor_width=hidden_size,\n to_tensor_width=hidden_size,\n from_seq_length=seq_length,\n to_seq_length=seq_length,\n num_attention_heads=num_attention_heads,\n size_per_head=self.size_per_head,\n attention_probs_dropout_prob=attention_probs_dropout_prob,\n use_one_hot_embeddings=use_one_hot_embeddings,\n initializer_range=initializer_range,\n use_relative_positions=use_relative_positions,\n has_attention_mask=True,\n do_return_2d_tensor=True,\n compute_type=compute_type)\n self.output = BertOutput(in_channels=hidden_size,\n out_channels=hidden_size,\n initializer_range=initializer_range,\n dropout_prob=hidden_dropout_prob,\n compute_type=compute_type)\n self.reshape = P.Reshape()\n self.shape = (-1, hidden_size)\n\n def construct(self, input_tensor, attention_mask):\n \"\"\"bert self attention\"\"\"\n input_tensor = self.reshape(input_tensor, self.shape)\n attention_output, attention_scores = self.attention(\n input_tensor, input_tensor, attention_mask)\n output = self.output(attention_output, input_tensor)\n return output, attention_scores\n\n\nclass BertEncoderCell(nn.Cell):\n \"\"\"\n Encoder cells used in BertTransformer.\n\n Args:\n hidden_size (int): Size of the bert encoder layers. Default: 768.\n seq_length (int): Length of input sequence. Default: 512.\n num_attention_heads (int): Number of attention heads. Default: 12.\n intermediate_size (int): Size of intermediate layer. Default: 3072.\n attention_probs_dropout_prob (float): The dropout probability for\n BertAttention. Default: 0.02.\n use_one_hot_embeddings (bool): Specifies whether to use one hot encoding form. Default: False.\n initializer_range (float): Initialization value of TruncatedNormal. Default: 0.02.\n hidden_dropout_prob (float): The dropout probability for BertOutput. Default: 0.1.\n use_relative_positions (bool): Specifies whether to use relative positions. Default: False.\n hidden_act (str): Activation function. Default: \"gelu\".\n compute_type (:class:`mindspore.dtype`): Compute type in attention. Default: mstype.float32.\n \"\"\"\n\n def __init__(self,\n hidden_size=768,\n seq_length=512,\n num_attention_heads=12,\n intermediate_size=3072,\n attention_probs_dropout_prob=0.02,\n use_one_hot_embeddings=False,\n initializer_range=0.02,\n hidden_dropout_prob=0.1,\n use_relative_positions=False,\n hidden_act=\"gelu\",\n compute_type=mstype.float32):\n super(BertEncoderCell, self).__init__()\n self.attention = BertSelfAttention(\n hidden_size=hidden_size,\n seq_length=seq_length,\n num_attention_heads=num_attention_heads,\n attention_probs_dropout_prob=attention_probs_dropout_prob,\n use_one_hot_embeddings=use_one_hot_embeddings,\n initializer_range=initializer_range,\n hidden_dropout_prob=hidden_dropout_prob,\n use_relative_positions=use_relative_positions,\n compute_type=compute_type)\n self.intermediate = nn.Dense(in_channels=hidden_size,\n out_channels=intermediate_size,\n activation=hidden_act,\n weight_init=TruncatedNormal(initializer_range)).to_float(compute_type)\n self.output = BertOutput(in_channels=intermediate_size,\n out_channels=hidden_size,\n initializer_range=initializer_range,\n dropout_prob=hidden_dropout_prob,\n compute_type=compute_type)\n\n def construct(self, hidden_states, attention_mask):\n \"\"\"bert encoder cell\"\"\"\n # self-attention\n attention_output, attention_scores = self.attention(\n hidden_states, attention_mask)\n # feed construct\n intermediate_output = self.intermediate(attention_output)\n # add and normalize\n output = self.output(intermediate_output, attention_output)\n return output, attention_scores\n\n\nclass BertTransformer(nn.Cell):\n \"\"\"\n Multi-layer bert transformer.\n\n Args:\n hidden_size (int): Size of the encoder layers.\n seq_length (int): Length of input sequence.\n num_hidden_layers (int): Number of hidden layers in encoder cells.\n num_attention_heads (int): Number of attention heads in encoder cells. Default: 12.\n intermediate_size (int): Size of intermediate layer in encoder cells. Default: 3072.\n attention_probs_dropout_prob (float): The dropout probability for\n BertAttention. Default: 0.1.\n use_one_hot_embeddings (bool): Specifies whether to use one hot encoding form. Default: False.\n initializer_range (float): Initialization value of TruncatedNormal. Default: 0.02.\n hidden_dropout_prob (float): The dropout probability for BertOutput. Default: 0.1.\n use_relative_positions (bool): Specifies whether to use relative positions. Default: False.\n hidden_act (str): Activation function used in the encoder cells. Default: \"gelu\".\n compute_type (:class:`mindspore.dtype`): Compute type in BertTransformer. Default: mstype.float32.\n return_all_encoders (bool): Specifies whether to return all encoders. Default: False.\n \"\"\"\n\n def __init__(self,\n hidden_size,\n seq_length,\n num_hidden_layers,\n num_attention_heads=12,\n intermediate_size=3072,\n attention_probs_dropout_prob=0.1,\n use_one_hot_embeddings=False,\n initializer_range=0.02,\n hidden_dropout_prob=0.1,\n use_relative_positions=False,\n hidden_act=\"gelu\",\n compute_type=mstype.float32,\n return_all_encoders=False):\n super(BertTransformer, self).__init__()\n self.return_all_encoders = return_all_encoders\n layers = []\n for _ in range(num_hidden_layers):\n layer = BertEncoderCell(hidden_size=hidden_size,\n seq_length=seq_length,\n num_attention_heads=num_attention_heads,\n intermediate_size=intermediate_size,\n attention_probs_dropout_prob=attention_probs_dropout_prob,\n use_one_hot_embeddings=use_one_hot_embeddings,\n initializer_range=initializer_range,\n hidden_dropout_prob=hidden_dropout_prob,\n use_relative_positions=use_relative_positions,\n hidden_act=hidden_act,\n compute_type=compute_type)\n layers.append(layer)\n self.layers = nn.CellList(layers)\n self.reshape = P.Reshape()\n self.shape = (-1, hidden_size)\n self.out_shape = (-1, seq_length, hidden_size)\n\n def construct(self, input_tensor, attention_mask):\n \"\"\"bert transformer\"\"\"\n prev_output = self.reshape(input_tensor, self.shape)\n all_encoder_layers = ()\n all_encoder_atts = ()\n all_encoder_outputs = ()\n all_encoder_outputs += (prev_output,)\n for layer_module in self.layers:\n layer_output, encoder_att = layer_module(\n prev_output, attention_mask)\n prev_output = layer_output\n if self.return_all_encoders:\n all_encoder_outputs += (layer_output,)\n layer_output = self.reshape(layer_output, self.out_shape)\n all_encoder_layers += (layer_output,)\n all_encoder_atts += (encoder_att,)\n if not self.return_all_encoders:\n prev_output = self.reshape(prev_output, self.out_shape)\n all_encoder_layers += (prev_output,)\n return all_encoder_layers, all_encoder_outputs, all_encoder_atts\n\n\nclass CreateAttentionMaskFromInputMask(nn.Cell):\n \"\"\"\n Create attention mask according to input mask.\n\n Args:\n config (Class): Configuration for BertModel.\n \"\"\"\n\n def __init__(self, config):\n super(CreateAttentionMaskFromInputMask, self).__init__()\n self.input_mask = None\n self.cast = P.Cast()\n self.reshape = P.Reshape()\n self.shape = (-1, 1, config.seq_length)\n\n def construct(self, input_mask):\n attention_mask = self.cast(\n self.reshape(\n input_mask,\n self.shape),\n mstype.float32)\n return attention_mask\n\n\nclass BertModel(nn.Cell):\n \"\"\"\n Bidirectional Encoder Representations from Transformers.\n\n Args:\n config (Class): Configuration for BertModel.\n is_training (bool): True for training mode. False for eval mode.\n use_one_hot_embeddings (bool): Specifies whether to use one hot encoding form. Default: False.\n \"\"\"\n\n def __init__(self,\n config,\n is_training,\n use_one_hot_embeddings=False):\n super(BertModel, self).__init__()\n config = copy.deepcopy(config)\n if not is_training:\n config.hidden_dropout_prob = 0.0\n config.attention_probs_dropout_prob = 0.0\n self.seq_length = config.seq_length\n self.hidden_size = config.hidden_size\n self.num_hidden_layers = config.num_hidden_layers\n self.embedding_size = config.hidden_size\n self.token_type_ids = None\n self.last_idx = self.num_hidden_layers - 1\n output_embedding_shape = [-1, self.seq_length,\n self.embedding_size]\n self.bert_embedding_lookup = EmbeddingLookup(\n vocab_size=config.vocab_size,\n embedding_size=self.embedding_size,\n embedding_shape=output_embedding_shape,\n use_one_hot_embeddings=use_one_hot_embeddings,\n initializer_range=config.initializer_range)\n self.bert_embedding_postprocessor = EmbeddingPostprocessor(\n use_relative_positions=config.use_relative_positions,\n embedding_size=self.embedding_size,\n embedding_shape=output_embedding_shape,\n use_token_type=True,\n token_type_vocab_size=config.type_vocab_size,\n use_one_hot_embeddings=use_one_hot_embeddings,\n initializer_range=0.02,\n max_position_embeddings=config.max_position_embeddings,\n dropout_prob=config.hidden_dropout_prob)\n self.bert_encoder = BertTransformer(\n hidden_size=self.hidden_size,\n seq_length=self.seq_length,\n num_attention_heads=config.num_attention_heads,\n num_hidden_layers=self.num_hidden_layers,\n intermediate_size=config.intermediate_size,\n attention_probs_dropout_prob=config.attention_probs_dropout_prob,\n use_one_hot_embeddings=use_one_hot_embeddings,\n initializer_range=config.initializer_range,\n hidden_dropout_prob=config.hidden_dropout_prob,\n use_relative_positions=config.use_relative_positions,\n hidden_act=config.hidden_act,\n compute_type=config.compute_type,\n return_all_encoders=True)\n self.cast = P.Cast()\n self.dtype = config.dtype\n self.cast_compute_type = SaturateCast(dst_type=config.compute_type)\n self.slice = P.StridedSlice()\n self.squeeze_1 = P.Squeeze(axis=1)\n self.dense = nn.Dense(self.hidden_size, self.hidden_size,\n activation=\"tanh\",\n weight_init=TruncatedNormal(config.initializer_range)).to_float(config.compute_type)\n self._create_attention_mask_from_input_mask = CreateAttentionMaskFromInputMask(\n config)\n\n def construct(self, input_ids, token_type_ids, input_mask):\n \"\"\"bert model\"\"\"\n # embedding\n word_embeddings, embedding_tables = self.bert_embedding_lookup(\n input_ids)\n embedding_output = self.bert_embedding_postprocessor(\n token_type_ids, word_embeddings)\n # attention mask [batch_size, seq_length, seq_length]\n attention_mask = self._create_attention_mask_from_input_mask(\n input_mask)\n # bert encoder\n encoder_output, encoder_layers, layer_atts = self.bert_encoder(self.cast_compute_type(embedding_output),\n attention_mask)\n sequence_output = self.cast(encoder_output[self.last_idx], self.dtype)\n # pooler\n batch_size = P.Shape()(input_ids)[0]\n sequence_slice = self.slice(sequence_output,\n (0, 0, 0),\n (batch_size, 1, self.hidden_size),\n (1, 1, 1))\n first_token = self.squeeze_1(sequence_slice)\n pooled_output = self.dense(first_token)\n pooled_output = self.cast(pooled_output, self.dtype)\n encoder_outputs = ()\n for output in encoder_layers:\n encoder_outputs += (self.cast(output, self.dtype),)\n attention_outputs = ()\n for output in layer_atts:\n attention_outputs += (self.cast(output, self.dtype),)\n return sequence_output, pooled_output, embedding_tables, encoder_outputs, attention_outputs\n\n\nclass TinyBertModel(nn.Cell):\n \"\"\"\n Bidirectional Encoder Representations from Transformers.\n\n Args:\n config (Class): Configuration for BertModel.\n is_training (bool): True for training mode. False for eval mode.\n use_one_hot_embeddings (bool): Specifies whether to use one hot encoding form. Default: False.\n \"\"\"\n\n def __init__(self,\n config,\n is_training,\n use_one_hot_embeddings=False):\n super(TinyBertModel, self).__init__()\n config = copy.deepcopy(config)\n if not is_training:\n config.hidden_dropout_prob = 0.0\n config.attention_probs_dropout_prob = 0.0\n self.seq_length = config.seq_length\n self.hidden_size = config.hidden_size\n self.num_hidden_layers = config.num_hidden_layers\n self.embedding_size = config.hidden_size\n self.token_type_ids = None\n self.last_idx = self.num_hidden_layers - 1\n output_embedding_shape = [-1, self.seq_length,\n self.embedding_size]\n self.tinybert_embedding_lookup = EmbeddingLookup(\n vocab_size=config.vocab_size,\n embedding_size=self.embedding_size,\n embedding_shape=output_embedding_shape,\n use_one_hot_embeddings=use_one_hot_embeddings,\n initializer_range=config.initializer_range)\n self.tinybert_embedding_postprocessor = EmbeddingPostprocessor(\n use_relative_positions=config.use_relative_positions,\n embedding_size=self.embedding_size,\n embedding_shape=output_embedding_shape,\n use_token_type=True,\n token_type_vocab_size=config.type_vocab_size,\n use_one_hot_embeddings=use_one_hot_embeddings,\n initializer_range=0.02,\n max_position_embeddings=config.max_position_embeddings,\n dropout_prob=config.hidden_dropout_prob)\n self.tinybert_encoder = BertTransformer(\n hidden_size=self.hidden_size,\n seq_length=self.seq_length,\n num_attention_heads=config.num_attention_heads,\n num_hidden_layers=self.num_hidden_layers,\n intermediate_size=config.intermediate_size,\n attention_probs_dropout_prob=config.attention_probs_dropout_prob,\n use_one_hot_embeddings=use_one_hot_embeddings,\n initializer_range=config.initializer_range,\n hidden_dropout_prob=config.hidden_dropout_prob,\n use_relative_positions=config.use_relative_positions,\n hidden_act=config.hidden_act,\n compute_type=config.compute_type,\n return_all_encoders=True)\n self.cast = P.Cast()\n self.dtype = config.dtype\n self.cast_compute_type = SaturateCast(dst_type=config.compute_type)\n self.slice = P.StridedSlice()\n self.squeeze_1 = P.Squeeze(axis=1)\n self.dense = nn.Dense(self.hidden_size, self.hidden_size,\n activation=\"tanh\",\n weight_init=TruncatedNormal(config.initializer_range)).to_float(config.compute_type)\n self._create_attention_mask_from_input_mask = CreateAttentionMaskFromInputMask(\n config)\n\n def construct(self, input_ids, token_type_ids, input_mask):\n \"\"\"tiny bert model\"\"\"\n # embedding\n word_embeddings, embedding_tables = self.tinybert_embedding_lookup(\n input_ids)\n embedding_output = self.tinybert_embedding_postprocessor(token_type_ids,\n word_embeddings)\n # attention mask [batch_size, seq_length, seq_length]\n attention_mask = self._create_attention_mask_from_input_mask(\n input_mask)\n # bert encoder\n encoder_output, encoder_layers, layer_atts = self.tinybert_encoder(self.cast_compute_type(embedding_output),\n attention_mask)\n sequence_output = self.cast(encoder_output[self.last_idx], self.dtype)\n # pooler\n batch_size = P.Shape()(input_ids)[0]\n sequence_slice = self.slice(sequence_output,\n (0, 0, 0),\n (batch_size, 1, self.hidden_size),\n (1, 1, 1))\n first_token = self.squeeze_1(sequence_slice)\n pooled_output = self.dense(first_token)\n pooled_output = self.cast(pooled_output, self.dtype)\n encoder_outputs = ()\n for output in encoder_layers:\n encoder_outputs += (self.cast(output, self.dtype),)\n attention_outputs = ()\n for output in layer_atts:\n attention_outputs += (self.cast(output, self.dtype),)\n return sequence_output, pooled_output, embedding_tables, encoder_outputs, attention_outputs\n\n\nclass BertModelCLS(nn.Cell):\n \"\"\"\n This class is responsible for classification task evaluation,\n i.e. XNLI(num_labels=3), LCQMC(num_labels=2), Chnsenti(num_labels=2).\n The returned output represents the final logits as the results of log_softmax is propotional to that of softmax.\n \"\"\"\n\n def __init__(self, config, is_training, num_labels=2, dropout_prob=0.0,\n use_one_hot_embeddings=False, phase_type=\"teacher\"):\n super(BertModelCLS, self).__init__()\n self.bert = BertModel(config, is_training, use_one_hot_embeddings)\n self.cast = P.Cast()\n self.weight_init = TruncatedNormal(config.initializer_range)\n self.log_softmax = P.LogSoftmax(axis=-1)\n self.dtype = config.dtype\n self.num_labels = num_labels\n self.phase_type = phase_type\n self.dense_1 = nn.Dense(config.hidden_size, self.num_labels, weight_init=self.weight_init,\n has_bias=True).to_float(config.compute_type)\n self.dropout = nn.ReLU()\n\n def construct(self, input_ids, token_type_id, input_mask):\n \"\"\"classification bert model\"\"\"\n _, pooled_output, _, seq_output, att_output = self.bert(\n input_ids, token_type_id, input_mask)\n cls = self.cast(pooled_output, self.dtype)\n cls = self.dropout(cls)\n logits = self.dense_1(cls)\n logits = self.cast(logits, self.dtype)\n log_probs = self.log_softmax(logits)\n return seq_output, att_output, logits, log_probs\n",
"# Copyright 2021 Huawei Technologies Co., Ltd\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 numpy as np\nimport tensorflow as tf\nimport cv2\nfrom PIL import Image\n\nfrom model_darknet19 import darknet\nfrom decode import decode\nfrom utils import preprocess_image, postprocess, draw_detection\nfrom config import anchors, class_names\nimport os \n\ndef main():\n labels_to_names={\n 0: 'person', 1: 'bicycle', 2: 'car', 3: 'motorbike', 4: 'aeroplane', 5: 'bus', 6: 'train', 7: 'truck',8: 'boat', 9:'traffic light', 10:'fire hydrant', 11:'stop sign',12:'parking meter', 13:'bench', 14:'bird',\n 15:'cat',16: 'dog',17:'horse', 18:'sheep',19:'cow',20:'elephant',21:'bear',22:'zebra',23:'giraffe',24:'backpack',25:'umbrella',26:'bandbag',27:'tie',28:'suitcase',29:'frisbee',30:'skis',31:'snowboard',32:'sports ball',\n 33:'kite',34:'baseball bat',35:'baseball glove',36:'skateboard',37:'surfboard',38:'tennis racket',39:'bottle',40:'wine glass',41:'cup',42:'fork',43:'knife',44:'spoon',45:'bowl',46:'banana',47:'apple',48:'sandwich',\n 49:'orange',50:'broccoli',51:'carrot',52:'hot dog',53:'pizza',54:'donut',55:'cake',56:'chair',57:'couch',58:'pottedplant',59:'bed',60:'diningtable',61:'toilet',62:'tv',63:'laptop',64:'mouse',65:'remote',66:'keyboard',\n 67:'cellphone',68:'microwave',69:'oven',70:'toaster',71:'sink',72:'refrigerator',73:'book',74:'clock',75:'vase',76:'scissors',77:'teddy bear',78:'hair direr',79:'toothbrush'}\n img_dir = \"./data/pascal_voc/VOCdevkit/VOC2007_test/JPEGImages\"\n for filename in os.listdir(img_dir):\n input_size = (416,416)\n \n image = cv2.imread(img_dir + '/' + filename)\n image_shape = image.shape[:2] #只取wh，channel=3不取\n\n # copy、resize416*416、归一化、在第0维增加存放batchsize维度\n image_cp = preprocess_image(image,input_size)\n tf.reset_default_graph() #运行到第2张就报错，需要加上这句，清除默认图形堆栈并充值默认图形\n \n # 【1】输入图片进入darknet19网络得到特征图，并进行解码得到：xmin xmax表示的边界框、置信度、类别概率\n tf_image = tf.placeholder(tf.float32,[1,input_size[0],input_size[1],3])\n model_output = darknet(tf_image) # darknet19网络输出的特征图\n output_sizes = input_size[0]//32, input_size[1]//32 # 特征图尺寸是图片下采样32倍\n output_decoded = decode(model_output=model_output,output_sizes=output_sizes,\n num_class=len(class_names),anchors=anchors) # 解码\n\n model_path = \"./yolov2_model/checkpoint_dir/yolo2_coco.ckpt\"\n saver = tf.train.Saver()\n with tf.Session() as sess:\n saver.restore(sess,model_path)\n bboxes,obj_probs,class_probs = sess.run(output_decoded,feed_dict={tf_image:image_cp})\n\n # 【2】筛选解码后的回归边界框——NMS(post process后期处理)\n bboxes,scores,class_max_index = postprocess(bboxes,obj_probs,class_probs,image_shape=image_shape)\n label_path_txt = \"./map_mul/detections_npu/\"\n with open(os.path.join(label_path_txt + filename.split('.')[0] + '.txt'), 'a+') as f:\n for i in range(len(scores)):\n if \" \" in labels_to_names[class_max_index[i]]:\n labels_to_name = labels_to_names[class_max_index[i]].split(' ')[0] + labels_to_names[class_max_index[i]].split(' ')[1]\n f.write(labels_to_name + \" \" + str(scores[i]) + \" \" + str(bboxes[i][0])+ \" \" + str(bboxes[i][1])+ \" \" + str(bboxes[i][2])+ \" \" + str(bboxes[i][3]) + '\\n')\n else:\n f.write(labels_to_names[class_max_index[i]] + \" \" + str(scores[i]) + \" \" + str(bboxes[i][0])+ \" \" + str(bboxes[i][1])+ \" \" + str(bboxes[i][2])+ \" \" + str(bboxes[i][3]) + '\\n')\n \n \n # 【3】绘制筛选后的边界框\n #print('-----',filename)\n #img_detection = draw_detection(image, bboxes, scores, class_max_index, class_names)\n #cv2.imwrite(f\"./VOC2007_jpeg_demo/\" + filename.split('.')[0]+'_' + \"detection.jpg\", img_detection)\n print('YOLO_v2 detection has done!')\n #cv2.imshow(\"detection_results\", img_detection)\n #cv2.waitKey(0)\n\nif __name__ == '__main__':\n main()\n",
"# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\n# Copyright 2020 Huawei Technologies Co., Ltd\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 collections\nimport logging\nimport numpy as np\nimport torch\nfrom caffe2.proto import caffe2_pb2\nfrom caffe2.python import core\n\nfrom .caffe2_modeling import META_ARCH_CAFFE2_EXPORT_TYPE_MAP, convert_batched_inputs_to_c2_format\nfrom .shared import ScopedWS, get_pb_arg_vali, get_pb_arg_vals, infer_device_type\n\nlogger = logging.getLogger(__name__)\n\n\nclass ProtobufModel(torch.nn.Module):\n \"\"\"\n A class works just like nn.Module in terms of inference, but running\n caffe2 model under the hood. Input/Output are Dict[str, tensor] whose keys\n are in external_input/output.\n \"\"\"\n\n def __init__(self, predict_net, init_net):\n logger.info(\"Initializing ProtobufModel ...\")\n super().__init__()\n assert isinstance(predict_net, caffe2_pb2.NetDef)\n assert isinstance(init_net, caffe2_pb2.NetDef)\n self.ws_name = \"__ws_tmp__\"\n self.net = core.Net(predict_net)\n\n with ScopedWS(self.ws_name, is_reset=True, is_cleanup=False) as ws:\n ws.RunNetOnce(init_net)\n for blob in self.net.Proto().external_input:\n if blob not in ws.Blobs():\n ws.CreateBlob(blob)\n ws.CreateNet(self.net)\n\n self._error_msgs = set()\n\n def forward(self, inputs_dict):\n assert all(inp in self.net.Proto().external_input for inp in inputs_dict)\n with ScopedWS(self.ws_name, is_reset=False, is_cleanup=False) as ws:\n for b, tensor in inputs_dict.items():\n ws.FeedBlob(b, tensor)\n try:\n ws.RunNet(self.net.Proto().name)\n except RuntimeError as e:\n if not str(e) in self._error_msgs:\n self._error_msgs.add(str(e))\n logger.warning(\"Encountered new RuntimeError: \\n{}\".format(str(e)))\n logger.warning(\"Catch the error and use partial results.\")\n\n outputs_dict = collections.OrderedDict(\n [(b, ws.FetchBlob(b)) for b in self.net.Proto().external_output]\n )\n # Remove outputs of current run, this is necessary in order to\n # prevent fetching the result from previous run if the model fails\n # in the middle.\n for b in self.net.Proto().external_output:\n # Needs to create uninitialized blob to make the net runable.\n # This is \"equivalent\" to: ws.RemoveBlob(b) then ws.CreateBlob(b),\n # but there'no such API.\n ws.FeedBlob(b, \"{}, a C++ native class of type nullptr (uninitialized).\".format(b))\n\n return outputs_dict\n\n\nclass ProtobufDetectionModel(torch.nn.Module):\n \"\"\"\n A class works just like a pytorch meta arch in terms of inference, but running\n caffe2 model under the hood.\n \"\"\"\n\n def __init__(self, predict_net, init_net, *, convert_outputs=None):\n \"\"\"\n Args:\n predict_net, init_net (core.Net): caffe2 nets\n convert_outptus (callable): a function that converts caffe2\n outputs to the same format of the original pytorch model.\n By default, use the one defined in the caffe2 meta_arch.\n \"\"\"\n super().__init__()\n self.protobuf_model = ProtobufModel(predict_net, init_net)\n self.size_divisibility = get_pb_arg_vali(predict_net, \"size_divisibility\", 0)\n self.device = get_pb_arg_vals(predict_net, \"device\", b\"cpu\").decode(\"ascii\")\n\n if convert_outputs is None:\n meta_arch = get_pb_arg_vals(predict_net, \"meta_architecture\", b\"GeneralizedRCNN\")\n meta_arch = META_ARCH_CAFFE2_EXPORT_TYPE_MAP[meta_arch.decode(\"ascii\")]\n self._convert_outputs = meta_arch.get_outputs_converter(predict_net, init_net)\n else:\n self._convert_outputs = convert_outputs\n\n def _infer_output_devices(self, inputs_dict):\n def _get_device_type(torch_tensor):\n assert torch_tensor.device.type in [\"cpu\", \"cuda\"]\n assert torch_tensor.device.index == 0\n return torch_tensor.device.type\n\n predict_net = self.protobuf_model.net.Proto()\n input_device_types = {\n (name, 0): _get_device_type(tensor) for name, tensor in inputs_dict.items()\n }\n device_type_map = infer_device_type(\n predict_net, known_status=input_device_types, device_name_style=\"pytorch\"\n )\n ssa, versions = core.get_ssa(predict_net)\n versioned_outputs = [(name, versions[name]) for name in predict_net.external_output]\n output_devices = [device_type_map[outp] for outp in versioned_outputs]\n return output_devices\n\n def _convert_inputs(self, batched_inputs):\n # currently all models convert inputs in the same way\n data, im_info = convert_batched_inputs_to_c2_format(\n batched_inputs, self.size_divisibility, self.device\n )\n return {\"data\": data, \"im_info\": im_info}\n\n def forward(self, batched_inputs):\n c2_inputs = self._convert_inputs(batched_inputs)\n c2_results = self.protobuf_model(c2_inputs)\n\n if any(t.device.type != \"cpu\" for _, t in c2_inputs.items()):\n output_devices = self._infer_output_devices(c2_inputs)\n else:\n output_devices = [\"cpu\" for _ in self.protobuf_model.net.Proto().external_output]\n\n def _cast_caffe2_blob_to_torch_tensor(blob, device):\n return torch.Tensor(blob).to(device) if isinstance(blob, np.ndarray) else None\n\n c2_results = {\n name: _cast_caffe2_blob_to_torch_tensor(c2_results[name], device)\n for name, device in zip(self.protobuf_model.net.Proto().external_output, output_devices)\n }\n\n return self._convert_outputs(batched_inputs, c2_inputs, c2_results)\n",
"# BSD 3-Clause License\n#\n# Copyright (c) 2017 xxxx\n# All rights reserved.\n# Copyright 2021 Huawei Technologies Co., Ltd\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# * Redistributions of source code must retain the above copyright notice, this\n# list of conditions and the following disclaimer.\n#\n# * Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n#\n# * Neither the name of the copyright holder nor the names of its\n# contributors may be used to endorse or promote products derived from\n# this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n# ============================================================================\nimport os\nimport numpy as np\nimport time\nimport datetime\nimport torch\nimport torchvision\nfrom torch import optim\nfrom torch.autograd import Variable\nimport torch.nn.functional as F\nfrom evaluation import *\nfrom network import U_Net,R2U_Net,AttU_Net,R2AttU_Net\nimport csv\n\ntry:\n import apex\n from apex import amp\nexcept ImportError:\n amp = None\n\nclass Solver(object):\n def __init__(self, config, train_loader, valid_loader, test_loader):\n\n # Data loader\n self.train_loader = train_loader\n self.valid_loader = valid_loader\n self.test_loader = test_loader\n\n # Models\n self.unet = None\n self.optimizer = None\n self.img_ch = config.img_ch\n self.output_ch = config.output_ch\n self.criterion = torch.nn.BCELoss()\n self.augmentation_prob = config.augmentation_prob\n\n # Hyper-parameters\n self.lr = config.lr\n self.beta1 = config.beta1\n self.beta2 = config.beta2\n\n # Training settings\n self.num_epochs = config.num_epochs\n self.num_epochs_decay = config.num_epochs_decay\n self.batch_size = config.batch_size\n self.config = config\n\n # Step size\n self.log_step = config.log_step\n self.val_step = config.val_step\n\n # Path\n self.model_path = config.model_path\n self.result_path = config.result_path\n self.mode = config.mode\n\n self.device = torch.device('npu:'+str(config.npu_idx) if torch.npu.is_available() else 'cpu')\n torch.npu.set_device(self.device)\n self.model_type = config.model_type\n self.t = config.t\n self.build_model()\n\n def build_model(self):\n \"\"\"Build generator and discriminator.\"\"\"\n if self.model_type =='U_Net':\n self.unet = U_Net(img_ch=3,output_ch=1)\n elif self.model_type =='R2U_Net':\n self.unet = R2U_Net(img_ch=3,output_ch=1,t=self.t)\n elif self.model_type =='AttU_Net':\n if self.config.pretrained:\n print(\"=> using pre-trained model '{}'\".format(self.model_type))\n self.unet = AttU_Net(img_ch=3,output_ch=1)\n print(\"Load my train models...\")\n pretrained_dict = \\\n torch.load(self.config.pth_path, map_location=\"cpu\")\n self.unet.load_state_dict(pretrained_dict, strict=False) \n print('%s is Successfully Loaded from %s'%(self.model_type,self.config.pth_path)) \n else:\n print(\"=> creating model '{}'\".format(self.model_type))\n self.unet = AttU_Net(img_ch=3,output_ch=1)\n elif self.model_type == 'R2AttU_Net':\n self.unet = R2AttU_Net(img_ch=3,output_ch=1,t=self.t)\n self.unet.to(self.device)\n self.optimizer = apex.optimizers.NpuFusedAdam(list(self.unet.parameters()), self.lr, [self.beta1, self.beta2])\n\n if self.config.apex:\n self.unet, self.optimizer = amp.initialize(self.unet, self.optimizer,opt_level=self.config.apex_opt_level, loss_scale=self.config.loss_scale_value,combine_grad=True)\n\n if self.config.distributed:\n self.unet = torch.nn.parallel.DistributedDataParallel(self.unet, device_ids=[self.config.npu_idx])\n\n # self.print_network(self.unet, self.model_type)\n\n def print_network(self, model, name):\n \"\"\"Print out the network information.\"\"\"\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n\n if self.config.is_master_node:\n print(model)\n print(name)\n print(\"The number of parameters: {}\".format(num_params))\n\n def to_data(self, x):\n \"\"\"Convert variable to tensor.\"\"\"\n if torch.npu.is_available():\n x = x.cpu()\n return x.data\n\n def update_lr(self, g_lr, d_lr):\n for param_group in self.optimizer.param_groups:\n param_group['lr'] = lr\n\n def reset_grad(self):\n \"\"\"Zero the gradient buffers.\"\"\"\n self.unet.zero_grad()\n\n def compute_accuracy(self,SR,GT):\n SR_flat = SR.view(-1)\n GT_flat = GT.view(-1)\n\n acc = GT_flat.data.cpu()==(SR_flat.data.cpu()>0.5)\n\n def tensor2img(self,x):\n img = (x[:,0,:,:]>x[:,1,:,:]).float()\n img = img*255\n return img\n\n\n def train(self):\n \"\"\"Train encoder, generator and discriminator.\"\"\"\n\n #====================================== Training ===========================================#\n #===========================================================================================#\n \n unet_path = os.path.join(self.model_path, '%s-%d-%.4f-%d-%.4f.pkl' %(self.model_type,self.num_epochs,self.lr,self.num_epochs_decay,self.augmentation_prob))\n\n # Train for Encoder\n lr = self.lr\n best_unet_score = 0.\n\n for epoch in range(self.num_epochs):\n if self.config.distributed:\n self.config.train_sampler.set_epoch(epoch)\n\n self.unet.train(True)\n epoch_loss = 0\n\n acc = 0. # Accuracy\n SE = 0. # Sensitivity (Recall)\n SP = 0. # Specificity\n PC = 0. # Precision\n F1 = 0. # F1 Score\n JS = 0. # Jaccard Similarity\n DC = 0. # Dice Coefficient\n length = 0\n start_time = 0\n steps = len(self.train_loader)\n for i, (images, GT) in enumerate(self.train_loader):\n # GT : Ground Truth\n if i == 5:\n start_time = time.time()\n images = images.to(self.device)\n GT = GT.to(self.device)\n\n # SR : Segmentation Result\n SR = self.unet(images)\n SR_probs = F.sigmoid(SR)\n SR_flat = SR_probs.view(SR_probs.size(0),-1)\n\n GT_flat = GT.view(GT.size(0),-1)\n loss = self.criterion(SR_flat,GT_flat)\n epoch_loss += loss.item()\n\n # Backprop + optimize\n self.reset_grad()\n if self.config.apex:\n with amp.scale_loss(loss, self.optimizer) as scaled_loss:\n scaled_loss.backward()\n else:\n loss.backward()\n self.optimizer.step()\n\n acc += get_accuracy(SR,GT)\n SE += get_sensitivity(SR,GT)\n SP += get_specificity(SR,GT)\n PC += get_precision(SR,GT)\n F1 += get_F1(SR,GT)\n JS += get_JS(SR,GT)\n DC += get_DC(SR,GT)\n length += 1\n if i > 5 and self.config.is_master_node:\n print('Epoch [%d/%d], Step:[%d/%d], Loss: %.4f, [Training] Acc: %.4f, SE: %.4f, SP: %.4f, PC: %.4f, F1: %.4f, JS: %.4f, DC: %.4f' % (\n epoch + 1, self.num_epochs, i, steps, loss, \\\n acc, SE, SP, PC, F1, JS, DC,))\n FPS = self.batch_size * (steps - 5) * self.config.rank_size / (time.time() - start_time)\n acc = acc/length\n SE = SE/length\n SP = SP/length\n PC = PC/length\n F1 = F1/length\n JS = JS/length\n DC = DC/length\n\n # Print the log info\n if self.config.is_master_node:\n print('Epoch [%d/%d], Loss: %.4f, \\n[Training] Acc: %.4f, SE: %.4f, SP: %.4f, PC: %.4f, F1: %.4f, JS: %.4f, DC: %.4f, FPS: %.2f' % (\n epoch+1, self.num_epochs, \\\n epoch_loss,\\\n acc,SE,SP,PC,F1,JS,DC,FPS))\n\n # Decay learning rate\n if (epoch+1) > (self.num_epochs - self.num_epochs_decay):\n lr -= (self.lr / float(self.num_epochs_decay))\n for param_group in self.optimizer.param_groups:\n param_group['lr'] = lr\n if self.config.is_master_node:\n print ('Decay learning rate to lr: {}.'.format(lr))\n \n\n #===================================== Validation ====================================#\n self.unet.train(False)\n self.unet.eval()\n\n acc = 0. # Accuracy\n SE = 0. # Sensitivity (Recall)\n SP = 0. # Specificity\n PC = 0. # Precision\n F1 = 0. # F1 Score\n JS = 0. # Jaccard Similarity\n DC = 0. # Dice Coefficient\n length=0\n for i, (images, GT) in enumerate(self.valid_loader):\n\n images = images.to(self.device)\n GT = GT.to(self.device)\n SR = F.sigmoid(self.unet(images))\n acc += get_accuracy(SR,GT)\n SE += get_sensitivity(SR,GT)\n SP += get_specificity(SR,GT)\n PC += get_precision(SR,GT)\n F1 += get_F1(SR,GT)\n JS += get_JS(SR,GT)\n DC += get_DC(SR,GT)\n \n length += 1\n \n acc = acc/length\n SE = SE/length\n SP = SP/length\n PC = PC/length\n F1 = F1/length\n JS = JS/length\n DC = DC/length\n unet_score = acc\n if self.config.is_master_node:\n print('[Validation] Acc: %.4f, SE: %.4f, SP: %.4f, PC: %.4f, F1: %.4f, JS: %.4f, DC: %.4f'%(acc,SE,SP,PC,F1,JS,DC))\n \n '''\n torchvision.utils.save_image(images.data.cpu(),\n os.path.join(self.result_path,\n '%s_valid_%d_image.png'%(self.model_type,epoch+1)))\n torchvision.utils.save_image(SR.data.cpu(),\n os.path.join(self.result_path,\n '%s_valid_%d_SR.png'%(self.model_type,epoch+1)))\n torchvision.utils.save_image(GT.data.cpu(),\n os.path.join(self.result_path,\n '%s_valid_%d_GT.png'%(self.model_type,epoch+1)))\n '''\n\n\n # Save Best U-Net model\n if unet_score > best_unet_score:\n best_unet_score = unet_score\n best_epoch = epoch\n best_unet = self.unet.state_dict()\n if self.config.is_master_node:\n print('Best %s model score : %.4f'%(self.model_type,best_unet_score))\n torch.save(best_unet,unet_path)\n \n #===================================== Test ====================================#\n del self.unet\n del best_unet\n self.build_model()\n if not self.config.distributed:\n self.unet.load_state_dict(torch.load(unet_path))\n\n self.unet.train(False)\n self.unet.eval()\n\n acc = 0. # Accuracy\n SE = 0. # Sensitivity (Recall)\n SP = 0. # Specificity\n PC = 0. # Precision\n F1 = 0. # F1 Score\n JS = 0. # Jaccard Similarity\n DC = 0. # Dice Coefficient\n length=0\n for i, (images, GT) in enumerate(self.valid_loader):\n\n images = images.to(self.device)\n GT = GT.to(self.device)\n SR = F.sigmoid(self.unet(images))\n acc += get_accuracy(SR,GT)\n SE += get_sensitivity(SR,GT)\n SP += get_specificity(SR,GT)\n PC += get_precision(SR,GT)\n F1 += get_F1(SR,GT)\n JS += get_JS(SR,GT)\n DC += get_DC(SR,GT)\n\n length += images.size(0)\n\n acc = acc/length\n SE = SE/length\n SP = SP/length\n PC = PC/length\n F1 = F1/length\n JS = JS/length\n DC = DC/length\n unet_score = acc\n print(\"Test finished, acc: %.3f \" % (acc))\n \n\n \n",
"# Copyright 2019 Ross Wightman\n# Copyright 2021 Huawei Technologies Co., Ltd\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\"\"\" AdamW Optimizer\nImpl copied from PyTorch master\n\"\"\"\nimport math\nimport torch\nfrom torch.optim.optimizer import Optimizer\n\n\nclass AdamW(Optimizer):\n r\"\"\"Implements AdamW algorithm.\n\n The original Adam algorithm was proposed in `Adam: A Method for Stochastic Optimization`_.\n The AdamW variant was proposed in `Decoupled Weight Decay Regularization`_.\n\n Arguments:\n params (iterable): iterable of parameters to optimize or dicts defining\n parameter groups\n lr (float, optional): learning rate (default: 1e-3)\n betas (Tuple[float, float], optional): coefficients used for computing\n running averages of gradient and its square (default: (0.9, 0.999))\n eps (float, optional): term added to the denominator to improve\n numerical stability (default: 1e-8)\n weight_decay (float, optional): weight decay coefficient (default: 1e-2)\n amsgrad (boolean, optional): whether to use the AMSGrad variant of this\n algorithm from the paper `On the Convergence of Adam and Beyond`_\n (default: False)\n\n .. _Adam\\: A Method for Stochastic Optimization:\n https://arxiv.org/abs/1412.6980\n .. _Decoupled Weight Decay Regularization:\n https://arxiv.org/abs/1711.05101\n .. _On the Convergence of Adam and Beyond:\n https://openreview.net/forum?id=ryQu7f-RZ\n \"\"\"\n\n def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8,\n weight_decay=1e-2, amsgrad=False):\n if not 0.0 <= lr:\n raise ValueError(\"Invalid learning rate: {}\".format(lr))\n if not 0.0 <= eps:\n raise ValueError(\"Invalid epsilon value: {}\".format(eps))\n if not 0.0 <= betas[0] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 0: {}\".format(betas[0]))\n if not 0.0 <= betas[1] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 1: {}\".format(betas[1]))\n defaults = dict(lr=lr, betas=betas, eps=eps,\n weight_decay=weight_decay, amsgrad=amsgrad)\n super(AdamW, self).__init__(params, defaults)\n\n def __setstate__(self, state):\n super(AdamW, self).__setstate__(state)\n for group in self.param_groups:\n group.setdefault('amsgrad', False)\n\n def step(self, closure=None):\n \"\"\"Performs a single optimization step.\n\n Arguments:\n closure (callable, optional): A closure that reevaluates the model\n and returns the loss.\n \"\"\"\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n\n # Perform stepweight decay\n p.data.mul_(1 - group['lr'] * group['weight_decay'])\n\n # Perform optimization step\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\n amsgrad = group['amsgrad']\n\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n # Exponential moving average of gradient values\n state['exp_avg'] = torch.zeros_like(p.data)\n # Exponential moving average of squared gradient values\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n if amsgrad:\n # Maintains max of all exp. moving avg. of sq. grad. values\n state['max_exp_avg_sq'] = torch.zeros_like(p.data)\n\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n if amsgrad:\n max_exp_avg_sq = state['max_exp_avg_sq']\n beta1, beta2 = group['betas']\n\n state['step'] += 1\n bias_correction1 = 1 - beta1 ** state['step']\n bias_correction2 = 1 - beta2 ** state['step']\n\n # Decay the first and second moment running average coefficient\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n if amsgrad:\n # Maintains the maximum of all 2nd moment running avg. till now\n torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)\n # Use the max. for normalizing running avg. of gradient\n denom = (max_exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\n else:\n denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\n\n step_size = group['lr'] / bias_correction1\n\n p.data.addcdiv_(-step_size, exp_avg, denom)\n\n return loss\n",
"# BSD 3-Clause License\n#\n# Copyright (c) 2017 xxxx\n# All rights reserved.\n# Copyright 2021 Huawei Technologies Co., Ltd\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# * Redistributions of source code must retain the above copyright notice, this\n# list of conditions and the following disclaimer.\n#\n# * Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n#\n# * Neither the name of the copyright holder nor the names of its\n# contributors may be used to endorse or promote products derived from\n# this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n# ============================================================================\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport torch\n\ndef decode_seg_map_sequence(label_masks, dataset='pascal'):\n rgb_masks = []\n for label_mask in label_masks:\n rgb_mask = decode_segmap(label_mask, dataset)\n rgb_masks.append(rgb_mask)\n rgb_masks = torch.from_numpy(np.array(rgb_masks).transpose([0, 3, 1, 2]))\n return rgb_masks\n\n\ndef decode_segmap(label_mask, dataset, plot=False):\n \"\"\"Decode segmentation class labels into a color image\n Args:\n label_mask (np.ndarray): an (M,N) array of integer values denoting\n the class label at each spatial location.\n plot (bool, optional): whether to show the resulting color image\n in a figure.\n Returns:\n (np.ndarray, optional): the resulting decoded color image.\n \"\"\"\n if dataset == 'pascal' or dataset == 'coco':\n n_classes = 21\n label_colours = get_pascal_labels()\n elif dataset == 'cityscapes':\n n_classes = 19\n label_colours = get_cityscapes_labels()\n else:\n raise NotImplementedError\n\n r = label_mask.copy()\n g = label_mask.copy()\n b = label_mask.copy()\n for ll in range(0, n_classes):\n r[label_mask == ll] = label_colours[ll, 0]\n g[label_mask == ll] = label_colours[ll, 1]\n b[label_mask == ll] = label_colours[ll, 2]\n rgb = np.zeros((label_mask.shape[0], label_mask.shape[1], 3))\n rgb[:, :, 0] = r / 255.0\n rgb[:, :, 1] = g / 255.0\n rgb[:, :, 2] = b / 255.0\n if plot:\n plt.imshow(rgb)\n plt.show()\n else:\n return rgb\n\n\ndef encode_segmap(mask):\n \"\"\"Encode segmentation label images as pascal classes\n Args:\n mask (np.ndarray): raw segmentation label image of dimension\n (M, N, 3), in which the Pascal classes are encoded as colours.\n Returns:\n (np.ndarray): class map with dimensions (M,N), where the value at\n a given location is the integer denoting the class index.\n \"\"\"\n mask = mask.astype(int)\n label_mask = np.zeros((mask.shape[0], mask.shape[1]), dtype=np.int16)\n for ii, label in enumerate(get_pascal_labels()):\n label_mask[np.where(np.all(mask == label, axis=-1))[:2]] = ii\n label_mask = label_mask.astype(int)\n return label_mask\n\n\ndef get_cityscapes_labels():\n return np.array([\n [128, 64, 128],\n [244, 35, 232],\n [70, 70, 70],\n [102, 102, 156],\n [190, 153, 153],\n [153, 153, 153],\n [250, 170, 30],\n [220, 220, 0],\n [107, 142, 35],\n [152, 251, 152],\n [0, 130, 180],\n [220, 20, 60],\n [255, 0, 0],\n [0, 0, 142],\n [0, 0, 70],\n [0, 60, 100],\n [0, 80, 100],\n [0, 0, 230],\n [119, 11, 32]])\n\n\ndef get_pascal_labels():\n \"\"\"Load the mapping that associates pascal classes with label colors\n Returns:\n np.ndarray with dimensions (21, 3)\n \"\"\"\n return np.asarray([[0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0],\n [0, 0, 128], [128, 0, 128], [0, 128, 128], [128, 128, 128],\n [64, 0, 0], [192, 0, 0], [64, 128, 0], [192, 128, 0],\n [64, 0, 128], [192, 0, 128], [64, 128, 128], [192, 128, 128],\n [0, 64, 0], [128, 64, 0], [0, 192, 0], [128, 192, 0],\n [0, 64, 128]])",
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n#\n# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n# Copyright 2021 Huawei Technologies Co., Ltd\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# @Time : 19-3-12 涓嬪崍9:03\n# @Author : MaybeShewill-CV\n# @Site : https://github.com/MaybeShewill-CV/CRNN_Tensorflow\n# @File : evaluation_tools.py\n# @IDE: PyCharm\n\"\"\"\nSome evaluation tools\n\"\"\"\nimport itertools\n\nimport numpy as np\nimport glog as log\n#import matplotlib.pyplot as plt\n\n\nSYNTH90K_CLASS_NAMES = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b',\n 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',\n 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ' ']\n\n\ndef compute_accuracy(ground_truth, predictions, display=False, mode='per_char'):\n \"\"\"\n Computes accuracy\n :param ground_truth:\n :param predictions:\n :param display: Whether to print values to stdout\n :param mode: if 'per_char' is selected then\n single_label_accuracy = correct_predicted_char_nums_of_single_sample / single_label_char_nums\n avg_label_accuracy = sum(single_label_accuracy) / label_nums\n if 'full_sequence' is selected then\n single_label_accuracy = 1 if the prediction result is exactly the same as label else 0\n avg_label_accuracy = sum(single_label_accuracy) / label_nums\n :return: avg_label_accuracy\n \"\"\"\n if mode == 'per_char':\n\n accuracy = []\n\n for index, label in enumerate(ground_truth):\n prediction = predictions[index]\n total_count = len(label)\n correct_count = 0\n try:\n for i, tmp in enumerate(label):\n if tmp == prediction[i]:\n correct_count += 1\n except IndexError:\n continue\n finally:\n try:\n accuracy.append(correct_count / total_count)\n except ZeroDivisionError:\n if len(prediction) == 0:\n accuracy.append(1)\n else:\n accuracy.append(0)\n avg_accuracy = np.mean(np.array(accuracy).astype(np.float32), axis=0)\n elif mode == 'full_sequence':\n try:\n correct_count = 0\n for index, label in enumerate(ground_truth):\n prediction = predictions[index]\n if prediction == label:\n correct_count += 1\n avg_accuracy = correct_count / len(ground_truth)\n except ZeroDivisionError:\n if not predictions:\n avg_accuracy = 1\n else:\n avg_accuracy = 0\n else:\n raise NotImplementedError('Other accuracy compute mode has not been implemented')\n\n if display:\n print('Mean accuracy is {:5f}'.format(avg_accuracy))\n\n return avg_accuracy\n\n\n#def plot_confusion_matrix(cm, classes=SYNTH90K_CLASS_NAMES,\n# normalize=False,\n# title='Confusion matrix',\n# cmap=plt.cm.Blues):\n# \"\"\"\n# This function prints and plots the confusion matrix.\n# Normalization can be applied by setting `normalize=True`.\n# \"\"\"\n# if normalize:\n# cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n# log.info(\"Normalized confusion matrix\")\n# else:\n# log.info('Confusion matrix, without normalization')\n#\n# print(cm)\n#\n# plt.imshow(cm, interpolation='nearest', cmap=cmap)\n# plt.title(title)\n# plt.colorbar()\n# tick_marks = np.arange(len(classes))\n# plt.xticks(tick_marks, classes, rotation=45)\n# plt.yticks(tick_marks, classes)\n#\n# fmt = '.2f' if normalize else 'd'\n# thresh = cm.max() / 2.\n# for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n# plt.text(j, i, format(cm[i, j], fmt),\n# horizontalalignment=\"center\",\n# color=\"white\" if cm[i, j] > thresh else \"black\")\n#\n# plt.ylabel('True label')\n# plt.xlabel('Predicted label')\n# plt.tight_layout()\n\n\ndef print_cm(cm, labels=SYNTH90K_CLASS_NAMES, hide_zeroes=False,\n hide_diagonal=False, hide_threshold=None):\n \"\"\"\n pretty print for confusion matrixes\n :param cm:\n :param labels:\n :param hide_zeroes:\n :param hide_diagonal:\n :param hide_threshold:\n :return:\n \"\"\"\n columnwidth = max([len(x) for x in labels] + [5]) # 5 is value length\n empty_cell = \" \" * columnwidth\n\n # Begin CHANGES\n fst_empty_cell = (columnwidth - 3) // 2 * \" \" + \"t/p\" + (columnwidth - 3) // 2 * \" \"\n\n if len(fst_empty_cell) < len(empty_cell):\n fst_empty_cell = \" \" * (len(empty_cell) - len(fst_empty_cell)) + fst_empty_cell\n # Print header\n print(\" \" + fst_empty_cell, end=\" \")\n # End CHANGES\n\n for label in labels:\n print(\"%{0}s\".format(columnwidth) % label, end=\" \")\n\n print()\n # Print rows\n for i, label1 in enumerate(labels):\n print(\" %{0}s\".format(columnwidth) % label1, end=\" \")\n for j in range(len(labels)):\n cell = \"%{0}.1f\".format(columnwidth) % cm[i, j]\n if hide_zeroes:\n cell = cell if float(cm[i, j]) != 0 else empty_cell\n if hide_diagonal:\n cell = cell if i != j else empty_cell\n if hide_threshold:\n cell = cell if cm[i, j] > hide_threshold else empty_cell\n print(cell, end=\" \")\n print()\n",
"# Copyright 2020 Huawei Technologies Co., Ltd\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 warnings\nwarnings.filterwarnings(\"ignore\")\nimport argparse\nimport math\nimport os\nimport random\nimport time\nfrom pathlib import Path\n\nimport numpy as np\nimport torch.distributed as dist\nimport torch.nn.functional as F\nimport torch.optim as optim\nimport torch.optim.lr_scheduler as lr_scheduler\nimport torch.utils.data\nimport yaml\nimport apex\nfrom torch.nn.parallel import DistributedDataParallel as DDP\nfrom torch.utils.tensorboard import SummaryWriter\nfrom tqdm import tqdm\nfrom apex import amp\n\nimport test # import test.py to get mAP after each epoch\nfrom models.models import *\nfrom utils.datasets import create_dataloader\nfrom utils.general import (\n check_img_size, torch_distributed_zero_first, labels_to_class_weights, plot_labels, check_anchors,\n labels_to_image_weights, compute_loss, plot_images, fitness, strip_optimizer, plot_results,\n get_latest_run, check_git_status, check_file, increment_dir, print_mutation, plot_evolution)\nfrom utils.google_utils import attempt_download\nfrom utils.torch_utils import init_seeds, ModelEMA, select_device, intersect_dicts\n\n\ndef set_seed_everything(seed):\n random.seed(seed)\n os.environ['PYTHONHASHSEED'] = str(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n torch.cuda.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\n\ndef train(hyp, opt, device, tb_writer=None):\n print(f'Hyperparameters {hyp}')\n log_dir = Path(tb_writer.log_dir) if tb_writer else Path(opt.logdir) / 'evolve' # logging directory\n wdir = str(log_dir / 'weights') + os.sep # weights directory\n os.makedirs(wdir, exist_ok=True)\n last = wdir + 'last.pt'\n best = wdir + 'best.pt'\n results_file = str(log_dir / 'results.txt')\n epochs, batch_size, total_batch_size, weights, rank = \\\n opt.epochs, opt.batch_size, opt.total_batch_size, opt.weights, opt.global_rank\n\n # TODO: Use DDP logging. Only the first process is allowed to log.\n # Save run settings\n with open(log_dir / 'hyp.yaml', 'w') as f:\n yaml.dump(hyp, f, sort_keys=False)\n with open(log_dir / 'opt.yaml', 'w') as f:\n yaml.dump(vars(opt), f, sort_keys=False)\n\n # Configure\n npu = device.type != 'cpu'\n # init_seeds(2 + rank)\n set_seed_everything(1234)\n with open(opt.data) as f:\n data_dict = yaml.load(f, Loader=yaml.FullLoader) # model dict\n train_path = data_dict['train']\n test_path = data_dict['val']\n nc, names = (1, ['item']) if opt.single_cls else (int(data_dict['nc']), data_dict['names']) # number classes, names\n assert len(names) == nc, '%g names found for nc=%g dataset in %s' % (len(names), nc, opt.data) # check\n\n # Model\n pretrained = weights.endswith('.pt')\n if pretrained:\n with torch_distributed_zero_first(rank):\n attempt_download(weights) # download if not found locally\n ckpt = torch.load(weights, map_location=device) # load checkpoint\n model = Darknet(opt.cfg).to(device) # create\n state_dict = {k: v for k, v in ckpt['model'].items() if model.state_dict()[k].numel() == v.numel()}\n model.load_state_dict(state_dict, strict=False)\n print('Transferred %g/%g items from %s' % (len(state_dict), len(model.state_dict()), weights)) # report\n else:\n model = Darknet(opt.cfg).to(device) # create\n print('')\n # Optimizer\n nbs = 64 # nominal batch size\n accumulate = max(round(nbs / total_batch_size), 1) # accumulate loss before optimizing\n hyp['weight_decay'] *= total_batch_size * accumulate / nbs # scale weight_decay\n\n pg0, pg1, pg2 = [], [], [] # optimizer parameter groups\n for k, v in dict(model.named_parameters()).items():\n if '.bias' in k:\n pg2.append(v) # biases\n elif 'Conv2d.weight' in k:\n pg1.append(v) # apply weight_decay\n else:\n pg0.append(v) # all else\n\n if opt.adam:\n optimizer = apex.optimizers.NpuFusedAdam(pg0, lr=hyp['lr0'], betas=(hyp['momentum'], 0.999)) # adjust beta1 to momentum\n else:\n optimizer = apex.optimizers.NpuFusedSGD(pg0, lr=hyp['lr0'], momentum=hyp['momentum'], nesterov=True)\n\n optimizer.add_param_group({'params': pg1, 'weight_decay': hyp['weight_decay']}) # add pg1 with weight_decay\n optimizer.add_param_group({'params': pg2}) # add pg2 (biases)\n print('Optimizer groups: %g .bias, %g conv.weight, %g other' % (len(pg2), len(pg1), len(pg0)))\n del pg0, pg1, pg2\n\n if opt.amp:\n model, optimizer = amp.initialize(model, optimizer, opt_level=opt.opt_level,\n loss_scale=opt.loss_scale, combine_grad=True)\n # Scheduler https://arxiv.org/pdf/1812.01187.pdf\n # https://pytorch.org/docs/stable/_modules/torch/optim/lr_scheduler.html#OneCycleLR\n lf = lambda x: (((1 + math.cos(x * math.pi / epochs)) / 2) ** 1.0) * 0.8 + 0.2 # cosine\n scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lf)\n # plot_lr_scheduler(optimizer, scheduler, epochs)\n\n # Resume\n start_epoch, best_fitness = 0, 0.0\n if pretrained:\n # Optimizer\n if ckpt['optimizer'] is not None:\n optimizer.load_state_dict(ckpt['optimizer'])\n best_fitness = ckpt['best_fitness']\n\n # Results\n if ckpt.get('training_results') is not None:\n with open(results_file, 'w') as file:\n file.write(ckpt['training_results']) # write results.txt\n\n # Epochs\n start_epoch = ckpt['epoch'] + 1\n if epochs < start_epoch:\n print('%s has been trained for %g epochs. Fine-tuning for %g additional epochs.' %\n (weights, ckpt['epoch'], epochs))\n epochs += ckpt['epoch'] # finetune additional epochs\n\n del ckpt, state_dict\n \n # Image sizes\n gs = 32 # grid size (max stride)\n imgsz, imgsz_test = [check_img_size(x, gs) for x in opt.img_size] # verify imgsz are gs-multiples\n\n # SyncBatchNorm\n if opt.sync_bn and npu and rank != -1:\n model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model).to(device)\n print('Using SyncBatchNorm()')\n\n # Exponential moving average\n ema = ModelEMA(model) if rank in [-1, 0] else None\n\n # DDP mode\n if npu and rank != -1:\n model = DDP(model, device_ids=[opt.local_rank], broadcast_buffers=False)\n\n # Trainloader\n dataloader, dataset = create_dataloader(train_path, imgsz, batch_size, gs, opt, hyp=hyp, augment=True,\n cache=opt.cache_images, rect=opt.rect, local_rank=rank,\n world_size=opt.world_size)\n mlc = np.concatenate(dataset.labels, 0)[:, 0].max() # max label class\n nb = len(dataloader) # number of batches\n assert mlc < nc, 'Label class %g exceeds nc=%g in %s. Possible class labels are 0-%g' % (mlc, nc, opt.data, nc - 1)\n\n # Testloader\n if rank in [-1, 0]:\n ema.updates = start_epoch * nb // accumulate # set EMA updates ***\n # local_rank is set to -1. Because only the first process is expected to do evaluation.\n testloader = create_dataloader(test_path, imgsz_test, batch_size, imgsz_test + 32, opt, hyp=hyp, augment=False,\n cache=opt.cache_images, pad=0.0, rect=True, local_rank=-1,\n world_size=opt.world_size)[0]\n\n # Model parameters\n hyp['cls'] *= nc / 80. # scale coco-tuned hyp['cls'] to current dataset\n model.nc = nc # attach number of classes to model\n model.hyp = hyp # attach hyperparameters to model\n model.gr = 1.0 # giou loss ratio (obj_loss = 1.0 or giou)\n model.class_weights = labels_to_class_weights(dataset.labels, nc).to(device) # attach class weights\n model.names = names\n\n # Class frequency\n if rank in [-1, 0]:\n labels = np.concatenate(dataset.labels, 0)\n c = torch.tensor(labels[:, 0]) # classes\n # cf = torch.bincount(c.long(), minlength=nc) + 1.\n # model._initialize_biases(cf.to(device))\n plot_labels(labels, save_dir=log_dir)\n if tb_writer:\n tb_writer.add_histogram('classes', c, 0)\n\n # Check anchors\n #if not opt.noautoanchor:\n # check_anchors(dataset, model=model, thr=hyp['anchor_t'], imgsz=imgsz)\n\n # Start training\n t0 = time.time()\n nw = max(3 * nb, 1e3) # number of warmup iterations, max(3 epochs, 1k iterations)\n # nw = min(nw, (epochs - start_epoch) / 2 * nb) # limit warmup to < 1/2 of training\n maps = np.zeros(nc) # mAP per class\n results = (0, 0, 0, 0, 0, 0, 0) # 'P', 'R', 'mAP', 'F1', 'val GIoU', 'val Objectness', 'val Classification'\n scheduler.last_epoch = start_epoch - 1 # do not move\n\n if rank in [0, -1]:\n print('Image sizes %g train, %g test' % (imgsz, imgsz_test))\n print('Using %g dataloader workers' % dataloader.num_workers)\n print('Starting training for %g epochs...' % epochs)\n # torch.autograd.set_detect_anomaly(True)\n for epoch in range(start_epoch, epochs): # epoch ------------------------------------------------------------------\n model.train()\n\n # Update image weights (optional)\n if dataset.image_weights:\n # Generate indices\n if rank in [-1, 0]:\n w = model.class_weights.cpu().numpy() * (1 - maps) ** 2 # class weights\n image_weights = labels_to_image_weights(dataset.labels, nc=nc, class_weights=w)\n dataset.indices = random.choices(range(dataset.n), weights=image_weights,\n k=dataset.n) # rand weighted idx\n # Broadcast if DDP\n if rank != -1:\n indices = torch.zeros([dataset.n], dtype=torch.int)\n if rank == 0:\n indices[:] = torch.from_tensor(dataset.indices, dtype=torch.int)\n dist.broadcast(indices, 0)\n if rank != 0:\n dataset.indices = indices.cpu().numpy()\n\n # Update mosaic border\n # b = int(random.uniform(0.25 * imgsz, 0.75 * imgsz + gs) // gs * gs)\n # dataset.mosaic_border = [b - imgsz, -b] # height, width borders\n\n mloss = torch.zeros(4, device=device) # mean losses\n if rank != -1:\n dataloader.sampler.set_epoch(epoch)\n pbar = enumerate(dataloader)\n if rank in [-1, 0]:\n print(('\\n' + '%10s' * 8) % ('Epoch', 'gpu_mem', 'GIoU', 'obj', 'cls', 'total', 'targets', 'img_size'))\n pbar = tqdm(pbar, total=nb) # progress bar\n optimizer.zero_grad()\n start_time = time.time()\n for i, (imgs, targets, paths, _) in pbar: # batch -------------------------------------------------------------\n ni = i + nb * epoch # number integrated batches (since train start)\n imgs = imgs.to(device, non_blocking=True).float() / 255.0 # uint8 to float32, 0-255 to 0.0-1.0\n\n # Warmup\n if ni <= nw:\n xi = [0, nw] # x interp\n # model.gr = np.interp(ni, xi, [0.0, 1.0]) # giou loss ratio (obj_loss = 1.0 or giou)\n accumulate = max(1, np.interp(ni, xi, [1, nbs / total_batch_size]).round())\n for j, x in enumerate(optimizer.param_groups):\n # bias lr falls from 0.1 to lr0, all other lrs rise from 0.0 to lr0\n x['lr'] = np.interp(ni, xi, [0.1 if j == 2 else 0.0, x['initial_lr'] * lf(epoch)])\n if 'momentum' in x:\n x['momentum'] = np.interp(ni, xi, [0.9, hyp['momentum']])\n\n # Multi-scale\n if opt.multi_scale:\n sz = random.randrange(imgsz * 0.5, imgsz * 1.5 + gs) // gs * gs # size\n sf = sz / max(imgs.shape[2:]) # scale factor\n if sf != 1:\n ns = [math.ceil(x * sf / gs) * gs for x in imgs.shape[2:]] # new shape (stretched to gs-multiple)\n imgs = F.interpolate(imgs, size=ns, mode='bilinear', align_corners=False)\n\n nt =targets.shape[0]\n batch_size = imgs.shape[0]\n nt_max = 32 * batch_size\n while nt > nt_max:\n nt_max *= 2\n print('targets len larger than nt_max, schedule to more bigger =', nt_max)\n pad_size = nt_max - nt\n pad_target = torch.nn.functional.pad(targets, [0, 0, 0, pad_size])\n pred = model(imgs)\n\n # Loss\n loss, loss_items = compute_loss(pred, pad_target.to(device), model) # scaled by batch_size\n if rank != -1:\n loss *= opt.world_size # gradient averaged between devices in DDP mode\n # if not torch.isfinite(loss):\n # print('WARNING: non-finite loss, ending training ', loss_items)\n # return results\n\n # Backward\n if opt.amp:\n with amp.scale_loss(loss, optimizer) as scaled_loss:\n scaled_loss.backward()\n else:\n loss.backward()\n\n # Optimize\n if ni % accumulate == 0:\n optimizer.step() # optimizer.step\n optimizer.zero_grad()\n if ema is not None:\n # x = torch.tensor([1.]).to(device)\n params_fp32_fused = optimizer.get_model_combined_params()\n ema.update(model, 'npu', params_fp32_fused[0])\n\n # Print\n if rank in [-1, 0]:\n mloss = (mloss * i + loss_items) / (i + 1) # update mean losses\n mem = '%.3gG' % (torch.npu.memory_reserved() / 1E9 if torch.npu.is_available() else 0) # (GB)\n s = ('%10s' * 2 + '%10.4g' * 6) % (\n '%g/%g' % (epoch, epochs - 1), mem, *mloss, targets.shape[0], imgs.shape[-1])\n pbar.set_description(s)\n\n # Plot\n if ni < 3:\n f = str(log_dir / ('train_batch%g.jpg' % ni)) # filename\n result = plot_images(images=imgs, targets=targets, paths=paths, fname=f)\n if tb_writer and result is not None:\n tb_writer.add_image(f, result, dataformats='HWC', global_step=epoch)\n # tb_writer.add_graph(model, imgs) # add model to tensorboard\n\n # end batch ------------------------------------------------------------------------------------------------\n if rank in [-1, 0]:\n epoch_time = time.time() - start_time\n print('Training speed is {} FPS'.format(total_batch_size * len(pbar) / (epoch_time)))\n # Scheduler\n scheduler.step()\n\n # DDP process 0 or single-GPU\n if rank in [-1, 0]:\n # mAP\n if ema is not None:\n ema.update_attr(model)\n final_epoch = epoch + 1 == epochs\n if not opt.notest: # Calculate mAP\n results, maps, times = test.test(opt.data,\n batch_size=batch_size,\n imgsz=imgsz_test,\n save_json=final_epoch and opt.data.endswith(os.sep + 'coco.yaml'),\n model=ema.ema.module if hasattr(ema.ema, 'module') else ema.ema,\n single_cls=opt.single_cls,\n dataloader=testloader,\n save_dir=log_dir)\n\n # Write\n with open(results_file, 'a') as f:\n f.write(s + '%10.4g' * 7 % results + '\\n') # P, R, mAP, F1, test_losses=(GIoU, obj, cls)\n if len(opt.name) and opt.bucket:\n os.system('gsutil cp %s gs://%s/results/results%s.txt' % (results_file, opt.bucket, opt.name))\n\n # Tensorboard\n if tb_writer:\n tags = ['train/giou_loss', 'train/obj_loss', 'train/cls_loss',\n 'metrics/precision', 'metrics/recall', 'metrics/mAP_0.5', 'metrics/mAP_0.5:0.95',\n 'val/giou_loss', 'val/obj_loss', 'val/cls_loss']\n for x, tag in zip(list(mloss[:-1]) + list(results), tags):\n tb_writer.add_scalar(tag, x, epoch)\n\n # Update best mAP\n fi = fitness(np.array(results).reshape(1, -1)) # fitness_i = weighted combination of [P, R, mAP, F1]\n if fi > best_fitness:\n best_fitness = fi\n\n # Save model\n save = (not opt.nosave) or (final_epoch and not opt.evolve)\n if save:\n with open(results_file, 'r') as f: # create checkpoint\n ckpt = {'epoch': epoch,\n 'best_fitness': best_fitness,\n 'training_results': f.read(),\n 'model': ema.ema.module.state_dict() if hasattr(ema, 'module') else ema.ema.state_dict(),\n 'optimizer': None if final_epoch else optimizer.state_dict()}\n\n # Save last, best and delete\n torch.save(ckpt, last)\n if epoch >= (epochs-5):\n torch.save(ckpt, last.replace('.pt','_{:03d}.pt'.format(epoch)))\n if (best_fitness == fi) and not final_epoch:\n torch.save(ckpt, best)\n del ckpt\n # end epoch ----------------------------------------------------------------------------------------------------\n # end training\n\n if rank in [-1, 0]:\n # Strip optimizers\n n = ('_' if len(opt.name) and not opt.name.isnumeric() else '') + opt.name\n fresults, flast, fbest = 'results%s.txt' % n, wdir + 'last%s.pt' % n, wdir + 'best%s.pt' % n\n for f1, f2 in zip([wdir + 'last.pt', wdir + 'best.pt', 'results.txt'], [flast, fbest, fresults]):\n if os.path.exists(f1):\n os.rename(f1, f2) # rename\n ispt = f2.endswith('.pt') # is *.pt\n strip_optimizer(f2) if ispt else None # strip optimizer\n os.system('gsutil cp %s gs://%s/weights' % (f2, opt.bucket)) if opt.bucket and ispt else None # upload\n # Finish\n if not opt.evolve:\n plot_results(save_dir=log_dir) # save as results.png\n print('%g epochs completed in %.3f hours.\\n' % (epoch - start_epoch + 1, (time.time() - t0) / 3600))\n\n dist.destroy_process_group() if rank not in [-1, 0] else None\n torch.npu.empty_cache()\n return results\n\ndef main(opt):\n # Resume\n if opt.resume:\n last = get_latest_run() if opt.resume == 'get_last' else opt.resume # resume from most recent run\n if last and not opt.weights:\n print(f'Resuming training from {last}')\n opt.weights = last if opt.resume and not opt.weights else opt.weights\n if opt.local_rank == -1 or (\"RANK\" in os.environ and os.environ[\"RANK\"] == \"0\"):\n check_git_status()\n\n opt.hyp = opt.hyp or ('data/hyp.scratch.yaml')\n opt.data, opt.cfg, opt.hyp = check_file(opt.data), check_file(opt.cfg), check_file(opt.hyp) # check files\n assert len(opt.cfg) or len(opt.weights), 'either --cfg or --weights must be specified'\n\n opt.img_size.extend([opt.img_size[-1]] * (2 - len(opt.img_size))) # extend to 2 sizes (train, test)\n # device = select_device(opt.device, batch_size=opt.batch_size)\n loc = 'npu:{}'.format(opt.device_id)\n device = torch.device('cpu') if opt.device_id == 'cpu' else torch.device(loc)\n opt.total_batch_size = opt.batch_size\n opt.world_size = 1\n opt.global_rank = -1\n\n # DDP mode\n if opt.local_rank != -1:\n assert torch.npu.device_count() > opt.local_rank\n torch.npu.set_device(opt.local_rank)\n device = torch.device('npu', opt.local_rank)\n dist.init_process_group(backend='nccl', init_method='env://') # distributed backend\n opt.world_size = dist.get_world_size()\n opt.global_rank = dist.get_rank()\n assert opt.batch_size % opt.world_size == 0, '--batch-size must be multiple of CUDA device count'\n opt.batch_size = opt.total_batch_size // opt.world_size\n else:\n torch.npu.set_device(loc)\n print(opt)\n with open(opt.hyp) as f:\n hyp = yaml.load(f, Loader=yaml.FullLoader) # load hyps\n\n # Train\n if not opt.evolve:\n tb_writer = None\n if opt.global_rank in [-1, 0]:\n print('Start Tensorboard with \"tensorboard --logdir %s\", view at http://localhost:6006/' % opt.logdir)\n tb_writer = SummaryWriter(log_dir=increment_dir(Path(opt.logdir) / 'exp', opt.name)) # runs/exp\n\n train(hyp, opt, device, tb_writer)\n\n # Evolve hyperparameters (optional)\n else:\n # Hyperparameter evolution metadata (mutation scale 0-1, lower_limit, upper_limit)\n meta = {'lr0': (1, 1e-5, 1e-1), # initial learning rate (SGD=1E-2, Adam=1E-3)\n 'momentum': (0.1, 0.6, 0.98), # SGD momentum/Adam beta1\n 'weight_decay': (1, 0.0, 0.001), # optimizer weight decay\n 'giou': (1, 0.02, 0.2), # GIoU loss gain\n 'cls': (1, 0.2, 4.0), # cls loss gain\n 'cls_pw': (1, 0.5, 2.0), # cls BCELoss positive_weight\n 'obj': (1, 0.2, 4.0), # obj loss gain (scale with pixels)\n 'obj_pw': (1, 0.5, 2.0), # obj BCELoss positive_weight\n 'iou_t': (0, 0.1, 0.7), # IoU training threshold\n 'anchor_t': (1, 2.0, 8.0), # anchor-multiple threshold\n 'fl_gamma': (0, 0.0, 2.0), # focal loss gamma (efficientDet default gamma=1.5)\n 'hsv_h': (1, 0.0, 0.1), # image HSV-Hue augmentation (fraction)\n 'hsv_s': (1, 0.0, 0.9), # image HSV-Saturation augmentation (fraction)\n 'hsv_v': (1, 0.0, 0.9), # image HSV-Value augmentation (fraction)\n 'degrees': (1, 0.0, 45.0), # image rotation (+/- deg)\n 'translate': (1, 0.0, 0.9), # image translation (+/- fraction)\n 'scale': (1, 0.0, 0.9), # image scale (+/- gain)\n 'shear': (1, 0.0, 10.0), # image shear (+/- deg)\n 'perspective': (1, 0.0, 0.001), # image perspective (+/- fraction), range 0-0.001\n 'flipud': (0, 0.0, 1.0), # image flip up-down (probability)\n 'fliplr': (1, 0.0, 1.0), # image flip left-right (probability)\n 'mixup': (1, 0.0, 1.0)} # image mixup (probability)\n\n assert opt.local_rank == -1, 'DDP mode not implemented for --evolve'\n opt.notest, opt.nosave = True, True # only test/save final epoch\n # ei = [isinstance(x, (int, float)) for x in hyp.values()] # evolvable indices\n yaml_file = Path('runs/evolve/hyp_evolved.yaml') # save best result here\n if opt.bucket:\n os.system('gsutil cp gs://%s/evolve.txt .' % opt.bucket) # download evolve.txt if exists\n\n for _ in range(100): # generations to evolve\n if os.path.exists('evolve.txt'): # if evolve.txt exists: select best hyps and mutate\n # Select parent(s)\n parent = 'single' # parent selection method: 'single' or 'weighted'\n x = np.loadtxt('evolve.txt', ndmin=2)\n n = min(5, len(x)) # number of previous results to consider\n x = x[np.argsort(-fitness(x))][:n] # top n mutations\n w = fitness(x) - fitness(x).min() # weights\n if parent == 'single' or len(x) == 1:\n # x = x[random.randint(0, n - 1)] # random selection\n x = x[random.choices(range(n), weights=w)[0]] # weighted selection\n elif parent == 'weighted':\n x = (x * w.reshape(n, 1)).sum(0) / w.sum() # weighted combination\n\n # Mutate\n mp, s = 0.9, 0.2 # mutation probability, sigma\n npr = np.random\n npr.seed(int(time.time()))\n g = np.array([x[0] for x in meta.values()]) # gains 0-1\n ng = len(meta)\n v = np.ones(ng)\n while all(v == 1): # mutate until a change occurs (prevent duplicates)\n v = (g * (npr.random(ng) < mp) * npr.randn(ng) * npr.random() * s + 1).clip(0.3, 3.0)\n for i, k in enumerate(hyp.keys()): # plt.hist(v.ravel(), 300)\n hyp[k] = float(x[i + 7] * v[i]) # mutate\n\n # Constrain to limits\n for k, v in meta.items():\n hyp[k] = max(hyp[k], v[1]) # lower limit\n hyp[k] = min(hyp[k], v[2]) # upper limit\n hyp[k] = round(hyp[k], 5) # significant digits\n\n # Train mutation\n results = train(hyp.copy(), opt, device)\n\n # Write mutation results\n print_mutation(hyp.copy(), results, yaml_file, opt.bucket)\n\n # Plot results\n plot_evolution(yaml_file)\n print('Hyperparameter evolution complete. Best results saved as: %s\\nCommand to train a new model with these '\n 'hyperparameters: $ python train.py --hyp %s' % (yaml_file, yaml_file))\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('--weights', type=str, default='yolov4.pt', help='initial weights path')\n parser.add_argument('--cfg', type=str, default='', help='model.yaml path')\n parser.add_argument('--data', type=str, default='data/coco128.yaml', help='data.yaml path')\n parser.add_argument('--hyp', type=str, default='', help='hyperparameters path, i.e. data/hyp.scratch.yaml')\n parser.add_argument('--epochs', type=int, default=300)\n parser.add_argument('--batch-size', type=int, default=16, help='total batch size for all GPUs')\n parser.add_argument('--img-size', nargs='+', type=int, default=[640, 640], help='train,test sizes')\n parser.add_argument('--rect', action='store_true', help='rectangular training')\n parser.add_argument('--resume', nargs='?', const='get_last', default=False,\n help='resume from given path/last.pt, or most recent run if blank')\n parser.add_argument('--nosave', action='store_true', help='only save final checkpoint')\n parser.add_argument('--notest', action='store_true', help='only test final epoch')\n parser.add_argument('--noautoanchor', action='store_true', help='disable autoanchor check')\n parser.add_argument('--evolve', action='store_true', help='evolve hyperparameters')\n parser.add_argument('--bucket', type=str, default='', help='gsutil bucket')\n parser.add_argument('--cache-images', action='store_true', help='cache images for faster training')\n parser.add_argument('--name', default='', help='renames results.txt to results_name.txt if supplied')\n parser.add_argument('--device_id', default='', help='npu device, i.e. 0 or 0,1,2,3 or cpu')\n parser.add_argument('--multi-scale', action='store_true', help='vary img-size +/- 50%%')\n parser.add_argument('--single-cls', action='store_true', help='train as single-class dataset')\n parser.add_argument('--adam', action='store_true', help='use torch.optim.Adam() optimizer')\n parser.add_argument('--sync-bn', action='store_true', help='use SyncBatchNorm, only available in DDP mode')\n parser.add_argument('--local_rank', type=int, default=-1, help='DDP parameter, do not modify')\n parser.add_argument('--logdir', type=str, default='runs/', help='logging directory')\n parser.add_argument('--amp', default=False, action='store_true',\n help='use amp to train the model')\n parser.add_argument('--loss_scale', default='dynamic',\n help='loss scale using in amp, default means dynamic loss scale')\n parser.add_argument('--opt-level', default='O1', type=str,\n help='loss scale using in amp, default O1')\n opt = parser.parse_args()\n main(opt)",
"# Copyright 2021 Huawei Technologies Co., Ltd\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport os\nimport json\nimport argparse\nimport numpy as np\n\n\ndef read_label_and_pred(npu_data_path):\n \"\"\"\n read label and predict\n :param npu_data_path:\n :return:\n \"\"\"\n label_list = []\n npu_data_list = []\n all_file = os.listdir(npu_data_path)\n all_file.sort()\n for result_file in all_file:\n if result_file.endswith(\".json\"):\n label = result_file.split(\"_\")[-1].split(\".\")[0].lower()\n label_list.append(label)\n result_path = npu_data_path + \"/\" + result_file\n with open(result_path, \"r\") as f:\n load_dict = json.load(f)\n npu_str = load_dict[\"MxpiTextsInfo\"][0][\"text\"][0]\n npu_data_list.append(npu_str)\n return label_list, npu_data_list\n\n\ndef compute_per_char(ground_truth, predictions):\n \"\"\"\n compute per char accuracy\n :param ground_truth:\n :param predictions:\n :return:\n \"\"\"\n accuracy = []\n for index, label in enumerate(ground_truth):\n prediction = predictions[index]\n total_count = len(label)\n correct_count = 0\n try:\n for i, tmp in enumerate(label):\n if tmp == prediction[i]:\n correct_count += 1\n except IndexError:\n continue\n finally:\n try:\n accuracy.append(correct_count / total_count)\n except ZeroDivisionError:\n if len(prediction) == 0:\n accuracy.append(1)\n else:\n accuracy.append(0)\n avg_accuracy = np.mean(np.array(accuracy).astype(np.float32), axis=0)\n print('PerChar Precision is {:5f}'.format(avg_accuracy))\n return avg_accuracy\n\n\ndef compute_full_sequence(ground_truth, predictions):\n \"\"\"\n compute full sequence accuracy\n :param ground_truth:\n :param predictions:\n :return:\n \"\"\"\n try:\n correct_count = 0\n mistake_count = [0] * 7\n for index, label in enumerate(ground_truth):\n prediction = predictions[index]\n if prediction == label:\n correct_count += 1\n else:\n mistake_count[int(index/100)] += 1\n avg_accuracy = correct_count / len(ground_truth)\n print(\"correct num: \" + str(correct_count))\n print(\"total count: \" + str(len(ground_truth)))\n print(\"mistake count: \" + str(mistake_count))\n except ZeroDivisionError:\n if not predictions:\n avg_accuracy = 1\n else:\n avg_accuracy = 0\n print('Full Sequence Precision is {:5f}'.format(avg_accuracy))\n return avg_accuracy\n\n\ndef compute_accuracy(ground_truth, predictions, mode='per_char'):\n \"\"\"\n Computes accuracy\n :param ground_truth:\n :param predictions:\n :param mode:\n :return: avg_label_accuracy\n \"\"\"\n if mode == \"per_char\":\n avg_accuracy = compute_per_char(ground_truth, predictions)\n elif mode == 'full_sequence':\n avg_accuracy = compute_full_sequence(ground_truth, predictions)\n else:\n raise NotImplementedError(\n 'Other accuracy compute model has not been implemented')\n\n return avg_accuracy\n\n\ndef main(args):\n \"\"\"\n main function\n :param args:\n :return:\n \"\"\"\n gt_data_list, npu_data_list = read_label_and_pred(args.npu_data_path)\n compute_accuracy(gt_data_list, npu_data_list, mode=\"per_char\")\n compute_accuracy(gt_data_list, npu_data_list, mode=\"full_sequence\")\n\n\ndef parse_args():\n \"\"\"\n parse args\n :return:\n \"\"\"\n parse = argparse.ArgumentParser()\n parse.add_argument('--npu_data_path', type=str,\n default='./npu_crnn_sdk_opencv/')\n return parse.parse_args()\n\n\nif __name__ == '__main__':\n main(parse_args())\n",
"# Copyright 2019 Ross Wightman\n# Copyright 2021 Huawei Technologies Co., Ltd\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\"\"\" Tensorflow Preprocessing Adapter\n\nAllows use of Tensorflow preprocessing pipeline in PyTorch Transform\n\nCopyright of original Tensorflow code below.\n\nHacked together by / Copyright 2020 Ross Wightman\n\"\"\"\n\n# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"ImageNet preprocessing for MnasNet.\"\"\"\nimport tensorflow as tf\nimport numpy as np\n\nIMAGE_SIZE = 224\nCROP_PADDING = 32\n\n\ndef distorted_bounding_box_crop(image_bytes,\n bbox,\n min_object_covered=0.1,\n aspect_ratio_range=(0.75, 1.33),\n area_range=(0.05, 1.0),\n max_attempts=100,\n scope=None):\n \"\"\"Generates cropped_image using one of the bboxes randomly distorted.\n\n See `tf.image.sample_distorted_bounding_box` for more documentation.\n\n Args:\n image_bytes: `Tensor` of binary image data.\n bbox: `Tensor` of bounding boxes arranged `[1, num_boxes, coords]`\n where each coordinate is [0, 1) and the coordinates are arranged\n as `[ymin, xmin, ymax, xmax]`. If num_boxes is 0 then use the whole\n image.\n min_object_covered: An optional `float`. Defaults to `0.1`. The cropped\n area of the image must contain at least this fraction of any bounding\n box supplied.\n aspect_ratio_range: An optional list of `float`s. The cropped area of the\n image must have an aspect ratio = width / height within this range.\n area_range: An optional list of `float`s. The cropped area of the image\n must contain a fraction of the supplied image within in this range.\n max_attempts: An optional `int`. Number of attempts at generating a cropped\n region of the image of the specified constraints. After `max_attempts`\n failures, return the entire image.\n scope: Optional `str` for name scope.\n Returns:\n cropped image `Tensor`\n \"\"\"\n with tf.name_scope(scope, 'distorted_bounding_box_crop', [image_bytes, bbox]):\n shape = tf.image.extract_jpeg_shape(image_bytes)\n sample_distorted_bounding_box = tf.image.sample_distorted_bounding_box(\n shape,\n bounding_boxes=bbox,\n min_object_covered=min_object_covered,\n aspect_ratio_range=aspect_ratio_range,\n area_range=area_range,\n max_attempts=max_attempts,\n use_image_if_no_bounding_boxes=True)\n bbox_begin, bbox_size, _ = sample_distorted_bounding_box\n\n # Crop the image to the specified bounding box.\n offset_y, offset_x, _ = tf.unstack(bbox_begin)\n target_height, target_width, _ = tf.unstack(bbox_size)\n crop_window = tf.stack([offset_y, offset_x, target_height, target_width])\n image = tf.image.decode_and_crop_jpeg(image_bytes, crop_window, channels=3)\n\n return image\n\n\ndef _at_least_x_are_equal(a, b, x):\n \"\"\"At least `x` of `a` and `b` `Tensors` are equal.\"\"\"\n match = tf.equal(a, b)\n match = tf.cast(match, tf.int32)\n return tf.greater_equal(tf.reduce_sum(match), x)\n\n\ndef _decode_and_random_crop(image_bytes, image_size, resize_method):\n \"\"\"Make a random crop of image_size.\"\"\"\n bbox = tf.constant([0.0, 0.0, 1.0, 1.0], dtype=tf.float32, shape=[1, 1, 4])\n image = distorted_bounding_box_crop(\n image_bytes,\n bbox,\n min_object_covered=0.1,\n aspect_ratio_range=(3. / 4, 4. / 3.),\n area_range=(0.08, 1.0),\n max_attempts=10,\n scope=None)\n original_shape = tf.image.extract_jpeg_shape(image_bytes)\n bad = _at_least_x_are_equal(original_shape, tf.shape(image), 3)\n\n image = tf.cond(\n bad,\n lambda: _decode_and_center_crop(image_bytes, image_size),\n lambda: tf.image.resize([image], [image_size, image_size], resize_method)[0])\n\n return image\n\n\ndef _decode_and_center_crop(image_bytes, image_size, resize_method):\n \"\"\"Crops to center of image with padding then scales image_size.\"\"\"\n shape = tf.image.extract_jpeg_shape(image_bytes)\n image_height = shape[0]\n image_width = shape[1]\n\n padded_center_crop_size = tf.cast(\n ((image_size / (image_size + CROP_PADDING)) *\n tf.cast(tf.minimum(image_height, image_width), tf.float32)),\n tf.int32)\n\n offset_height = ((image_height - padded_center_crop_size) + 1) // 2\n offset_width = ((image_width - padded_center_crop_size) + 1) // 2\n crop_window = tf.stack([offset_height, offset_width,\n padded_center_crop_size, padded_center_crop_size])\n image = tf.image.decode_and_crop_jpeg(image_bytes, crop_window, channels=3)\n image = tf.image.resize([image], [image_size, image_size], resize_method)[0]\n\n return image\n\n\ndef _flip(image):\n \"\"\"Random horizontal image flip.\"\"\"\n image = tf.image.random_flip_left_right(image)\n return image\n\n\ndef preprocess_for_train(image_bytes, use_bfloat16, image_size=IMAGE_SIZE, interpolation='bicubic'):\n \"\"\"Preprocesses the given image for evaluation.\n\n Args:\n image_bytes: `Tensor` representing an image binary of arbitrary size.\n use_bfloat16: `bool` for whether to use bfloat16.\n image_size: image size.\n interpolation: image interpolation method\n\n Returns:\n A preprocessed image `Tensor`.\n \"\"\"\n resize_method = tf.image.ResizeMethod.BICUBIC if interpolation == 'bicubic' else tf.image.ResizeMethod.BILINEAR\n image = _decode_and_random_crop(image_bytes, image_size, resize_method)\n image = _flip(image)\n image = tf.reshape(image, [image_size, image_size, 3])\n image = tf.image.convert_image_dtype(\n image, dtype=tf.bfloat16 if use_bfloat16 else tf.float32)\n return image\n\n\ndef preprocess_for_eval(image_bytes, use_bfloat16, image_size=IMAGE_SIZE, interpolation='bicubic'):\n \"\"\"Preprocesses the given image for evaluation.\n\n Args:\n image_bytes: `Tensor` representing an image binary of arbitrary size.\n use_bfloat16: `bool` for whether to use bfloat16.\n image_size: image size.\n interpolation: image interpolation method\n\n Returns:\n A preprocessed image `Tensor`.\n \"\"\"\n resize_method = tf.image.ResizeMethod.BICUBIC if interpolation == 'bicubic' else tf.image.ResizeMethod.BILINEAR\n image = _decode_and_center_crop(image_bytes, image_size, resize_method)\n image = tf.reshape(image, [image_size, image_size, 3])\n image = tf.image.convert_image_dtype(\n image, dtype=tf.bfloat16 if use_bfloat16 else tf.float32)\n return image\n\n\ndef preprocess_image(image_bytes,\n is_training=False,\n use_bfloat16=False,\n image_size=IMAGE_SIZE,\n interpolation='bicubic'):\n \"\"\"Preprocesses the given image.\n\n Args:\n image_bytes: `Tensor` representing an image binary of arbitrary size.\n is_training: `bool` for whether the preprocessing is for training.\n use_bfloat16: `bool` for whether to use bfloat16.\n image_size: image size.\n interpolation: image interpolation method\n\n Returns:\n A preprocessed image `Tensor` with value range of [0, 255].\n \"\"\"\n if is_training:\n return preprocess_for_train(image_bytes, use_bfloat16, image_size, interpolation)\n else:\n return preprocess_for_eval(image_bytes, use_bfloat16, image_size, interpolation)\n\n\nclass TfPreprocessTransform:\n\n def __init__(self, is_training=False, size=224, interpolation='bicubic'):\n self.is_training = is_training\n self.size = size[0] if isinstance(size, tuple) else size\n self.interpolation = interpolation\n self._image_bytes = None\n self.process_image = self._build_tf_graph()\n self.sess = None\n\n def _build_tf_graph(self):\n with tf.device('/cpu:0'):\n self._image_bytes = tf.placeholder(\n shape=[],\n dtype=tf.string,\n )\n img = preprocess_image(\n self._image_bytes, self.is_training, False, self.size, self.interpolation)\n return img\n\n def __call__(self, image_bytes):\n if self.sess is None:\n self.sess = tf.Session()\n img = self.sess.run(self.process_image, feed_dict={self._image_bytes: image_bytes})\n img = img.round().clip(0, 255).astype(np.uint8)\n if img.ndim < 3:\n img = np.expand_dims(img, axis=-1)\n img = np.rollaxis(img, 2) # HWC to CHW\n return img\n",
"#\n# BSD 3-Clause License\n#\n# Copyright (c) 2017 xxxx\n# All rights reserved.\n# Copyright 2021 Huawei Technologies Co., Ltd\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# * Redistributions of source code must retain the above copyright notice, this\n# list of conditions and the following disclaimer.\n#\n# * Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n#\n# * Neither the name of the copyright holder nor the names of its\n# contributors may be used to endorse or promote products derived from\n# this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n# ============================================================================\n#from collections import OrderedDict\n\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\n\nfrom torchvision.ops import misc as misc_nn_ops\nfrom torchvision.ops import MultiScaleRoIAlign\n\nfrom ..utils import load_state_dict_from_url\n\nfrom .faster_rcnn import FasterRCNN\nfrom .backbone_utils import resnet_fpn_backbone\n\n__all__ = [\n \"MaskRCNN\", \"maskrcnn_resnet50_fpn\",\n]\n\n\nclass MaskRCNN(FasterRCNN):\n \"\"\"\n Implements Mask R-CNN.\n\n The input to the model is expected to be a list of tensors, each of shape [C, H, W], one for each\n image, and should be in 0-1 range. Different images can have different sizes.\n\n The behavior of the model changes depending if it is in training or evaluation mode.\n\n During training, the model expects both the input tensors, as well as a targets (list of dictionary),\n containing:\n - boxes (FloatTensor[N, 4]): the ground-truth boxes in [x1, y1, x2, y2] format, with values\n between 0 and H and 0 and W\n - labels (Int64Tensor[N]): the class label for each ground-truth box\n - masks (UInt8Tensor[N, H, W]): the segmentation binary masks for each instance\n\n The model returns a Dict[Tensor] during training, containing the classification and regression\n losses for both the RPN and the R-CNN, and the mask loss.\n\n During inference, the model requires only the input tensors, and returns the post-processed\n predictions as a List[Dict[Tensor]], one for each input image. The fields of the Dict are as\n follows:\n - boxes (FloatTensor[N, 4]): the predicted boxes in [x1, y1, x2, y2] format, with values between\n 0 and H and 0 and W\n - labels (Int64Tensor[N]): the predicted labels for each image\n - scores (Tensor[N]): the scores or each prediction\n - masks (UInt8Tensor[N, 1, H, W]): the predicted masks for each instance, in 0-1 range. In order to\n obtain the final segmentation masks, the soft masks can be thresholded, generally\n with a value of 0.5 (mask >= 0.5)\n\n Arguments:\n backbone (nn.Module): the network used to compute the features for the model.\n It should contain a out_channels attribute, which indicates the number of output\n channels that each feature map has (and it should be the same for all feature maps).\n The backbone should return a single Tensor or and OrderedDict[Tensor].\n num_classes (int): number of output classes of the model (including the background).\n If box_predictor is specified, num_classes should be None.\n min_size (int): minimum size of the image to be rescaled before feeding it to the backbone\n max_size (int): maximum size of the image to be rescaled before feeding it to the backbone\n image_mean (Tuple[float, float, float]): mean values used for input normalization.\n They are generally the mean values of the dataset on which the backbone has been trained\n on\n image_std (Tuple[float, float, float]): std values used for input normalization.\n They are generally the std values of the dataset on which the backbone has been trained on\n rpn_anchor_generator (AnchorGenerator): module that generates the anchors for a set of feature\n maps.\n rpn_head (nn.Module): module that computes the objectness and regression deltas from the RPN\n rpn_pre_nms_top_n_train (int): number of proposals to keep before applying NMS during training\n rpn_pre_nms_top_n_test (int): number of proposals to keep before applying NMS during testing\n rpn_post_nms_top_n_train (int): number of proposals to keep after applying NMS during training\n rpn_post_nms_top_n_test (int): number of proposals to keep after applying NMS during testing\n rpn_nms_thresh (float): NMS threshold used for postprocessing the RPN proposals\n rpn_fg_iou_thresh (float): minimum IoU between the anchor and the GT box so that they can be\n considered as positive during training of the RPN.\n rpn_bg_iou_thresh (float): maximum IoU between the anchor and the GT box so that they can be\n considered as negative during training of the RPN.\n rpn_batch_size_per_image (int): number of anchors that are sampled during training of the RPN\n for computing the loss\n rpn_positive_fraction (float): proportion of positive anchors in a mini-batch during training\n of the RPN\n box_roi_pool (MultiScaleRoIAlign): the module which crops and resizes the feature maps in\n the locations indicated by the bounding boxes\n box_head (nn.Module): module that takes the cropped feature maps as input\n box_predictor (nn.Module): module that takes the output of box_head and returns the\n classification logits and box regression deltas.\n box_score_thresh (float): during inference, only return proposals with a classification score\n greater than box_score_thresh\n box_nms_thresh (float): NMS threshold for the prediction head. Used during inference\n box_detections_per_img (int): maximum number of detections per image, for all classes.\n box_fg_iou_thresh (float): minimum IoU between the proposals and the GT box so that they can be\n considered as positive during training of the classification head\n box_bg_iou_thresh (float): maximum IoU between the proposals and the GT box so that they can be\n considered as negative during training of the classification head\n box_batch_size_per_image (int): number of proposals that are sampled during training of the\n classification head\n box_positive_fraction (float): proportion of positive proposals in a mini-batch during training\n of the classification head\n bbox_reg_weights (Tuple[float, float, float, float]): weights for the encoding/decoding of the\n bounding boxes\n mask_roi_pool (MultiScaleRoIAlign): the module which crops and resizes the feature maps in\n the locations indicated by the bounding boxes, which will be used for the mask head.\n mask_head (nn.Module): module that takes the cropped feature maps as input\n mask_predictor (nn.Module): module that takes the output of the mask_head and returns the\n segmentation mask logits\n\n Example::\n\n >>> import torchvision\n >>> from torchvision.models.detection import MaskRCNN\n >>> from torchvision.models.detection.rpn import AnchorGenerator\n >>>\n >>> # load a pre-trained model for classification and return\n >>> # only the features\n >>> backbone = torchvision.models.mobilenet_v2(pretrained=True).features\n >>> # MaskRCNN needs to know the number of\n >>> # output channels in a backbone. For mobilenet_v2, it's 1280\n >>> # so we need to add it here\n >>> backbone.out_channels = 1280\n >>>\n >>> # let's make the RPN generate 5 x 3 anchors per spatial\n >>> # location, with 5 different sizes and 3 different aspect\n >>> # ratios. We have a Tuple[Tuple[int]] because each feature\n >>> # map could potentially have different sizes and\n >>> # aspect ratios\n >>> anchor_generator = AnchorGenerator(sizes=((32, 64, 128, 256, 512),),\n >>> aspect_ratios=((0.5, 1.0, 2.0),))\n >>>\n >>> # let's define what are the feature maps that we will\n >>> # use to perform the region of interest cropping, as well as\n >>> # the size of the crop after rescaling.\n >>> # if your backbone returns a Tensor, featmap_names is expected to\n >>> # be [0]. More generally, the backbone should return an\n >>> # OrderedDict[Tensor], and in featmap_names you can choose which\n >>> # feature maps to use.\n >>> roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[0],\n >>> output_size=7,\n >>> sampling_ratio=2)\n >>>\n >>> mask_roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[0],\n >>> output_size=14,\n >>> sampling_ratio=2)\n >>> # put the pieces together inside a FasterRCNN model\n >>> model = MaskRCNN(backbone,\n >>> num_classes=2,\n >>> rpn_anchor_generator=anchor_generator,\n >>> box_roi_pool=roi_pooler,\n >>> mask_roi_pool=mask_roi_pooler)\n >>> model.eval()\n >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]\n >>> predictions = model(x)\n \"\"\"\n def __init__(self, backbone, num_classes=None,\n # transform parameters\n min_size=800, max_size=1333,\n image_mean=None, image_std=None,\n # RPN parameters\n rpn_anchor_generator=None, rpn_head=None,\n rpn_pre_nms_top_n_train=2000, rpn_pre_nms_top_n_test=1000,\n rpn_post_nms_top_n_train=2000, rpn_post_nms_top_n_test=1000,\n rpn_nms_thresh=0.7,\n rpn_fg_iou_thresh=0.7, rpn_bg_iou_thresh=0.3,\n rpn_batch_size_per_image=256, rpn_positive_fraction=0.5,\n # Box parameters\n box_roi_pool=None, box_head=None, box_predictor=None,\n box_score_thresh=0.05, box_nms_thresh=0.5, box_detections_per_img=100,\n box_fg_iou_thresh=0.5, box_bg_iou_thresh=0.5,\n box_batch_size_per_image=512, box_positive_fraction=0.25,\n bbox_reg_weights=None,\n # Mask parameters\n mask_roi_pool=None, mask_head=None, mask_predictor=None):\n\n assert isinstance(mask_roi_pool, (MultiScaleRoIAlign, type(None)))\n\n if num_classes is not None:\n if mask_predictor is not None:\n raise ValueError(\"num_classes should be None when mask_predictor is specified\")\n\n out_channels = backbone.out_channels\n\n if mask_roi_pool is None:\n mask_roi_pool = MultiScaleRoIAlign(\n featmap_names=[0, 1, 2, 3],\n output_size=14,\n sampling_ratio=2)\n\n if mask_head is None:\n mask_layers = (256, 256, 256, 256)\n mask_dilation = 1\n mask_head = MaskRCNNHeads(out_channels, mask_layers, mask_dilation)\n\n if mask_predictor is None:\n mask_predictor_in_channels = 256 # == mask_layers[-1]\n mask_dim_reduced = 256\n mask_predictor = MaskRCNNPredictor(mask_predictor_in_channels,\n mask_dim_reduced, num_classes)\n\n super(MaskRCNN, self).__init__(\n backbone, num_classes,\n # transform parameters\n min_size, max_size,\n image_mean, image_std,\n # RPN-specific parameters\n rpn_anchor_generator, rpn_head,\n rpn_pre_nms_top_n_train, rpn_pre_nms_top_n_test,\n rpn_post_nms_top_n_train, rpn_post_nms_top_n_test,\n rpn_nms_thresh,\n rpn_fg_iou_thresh, rpn_bg_iou_thresh,\n rpn_batch_size_per_image, rpn_positive_fraction,\n # Box parameters\n box_roi_pool, box_head, box_predictor,\n box_score_thresh, box_nms_thresh, box_detections_per_img,\n box_fg_iou_thresh, box_bg_iou_thresh,\n box_batch_size_per_image, box_positive_fraction,\n bbox_reg_weights)\n\n self.roi_heads.mask_roi_pool = mask_roi_pool\n self.roi_heads.mask_head = mask_head\n self.roi_heads.mask_predictor = mask_predictor\n\n\nclass MaskRCNNHeads(nn.Sequential):\n def __init__(self, in_channels, layers, dilation):\n \"\"\"\n Arguments:\n num_classes (int): number of output classes\n input_size (int): number of channels of the input once it's flattened\n representation_size (int): size of the intermediate representation\n \"\"\"\n d = OrderedDict()\n next_feature = in_channels\n for layer_idx, layer_features in enumerate(layers, 1):\n d[\"mask_fcn{}\".format(layer_idx)] = misc_nn_ops.Conv2d(\n next_feature, layer_features, kernel_size=3,\n stride=1, padding=dilation, dilation=dilation)\n d[\"relu{}\".format(layer_idx)] = nn.ReLU(inplace=True)\n next_feature = layer_features\n\n super(MaskRCNNHeads, self).__init__(d)\n for name, param in self.named_parameters():\n if \"weight\" in name:\n nn.init.kaiming_normal_(param, mode=\"fan_out\", nonlinearity=\"relu\")\n # elif \"bias\" in name:\n # nn.init.constant_(param, 0)\n\n\nclass MaskRCNNPredictor(nn.Sequential):\n def __init__(self, in_channels, dim_reduced, num_classes):\n super(MaskRCNNPredictor, self).__init__(OrderedDict([\n (\"conv5_mask\", misc_nn_ops.ConvTranspose2d(in_channels, dim_reduced, 2, 2, 0)),\n (\"relu\", nn.ReLU(inplace=True)),\n (\"mask_fcn_logits\", misc_nn_ops.Conv2d(dim_reduced, num_classes, 1, 1, 0)),\n ]))\n\n for name, param in self.named_parameters():\n if \"weight\" in name:\n nn.init.kaiming_normal_(param, mode=\"fan_out\", nonlinearity=\"relu\")\n # elif \"bias\" in name:\n # nn.init.constant_(param, 0)\n\n\nmodel_urls = {\n 'maskrcnn_resnet50_fpn_coco':\n 'https://download.pytorch.org/models/maskrcnn_resnet50_fpn_coco-bf2d0c1e.pth',\n}\n\n\ndef maskrcnn_resnet50_fpn(pretrained=False, progress=True,\n num_classes=91, pretrained_backbone=True, **kwargs):\n \"\"\"\n Constructs a Mask R-CNN model with a ResNet-50-FPN backbone.\n\n The input to the model is expected to be a list of tensors, each of shape ``[C, H, W]``, one for each\n image, and should be in ``0-1`` range. Different images can have different sizes.\n\n The behavior of the model changes depending if it is in training or evaluation mode.\n\n During training, the model expects both the input tensors, as well as a targets (list of dictionary),\n containing:\n - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with values\n between ``0`` and ``H`` and ``0`` and ``W``\n - labels (``Int64Tensor[N]``): the class label for each ground-truth box\n - masks (``UInt8Tensor[N, H, W]``): the segmentation binary masks for each instance\n\n The model returns a ``Dict[Tensor]`` during training, containing the classification and regression\n losses for both the RPN and the R-CNN, and the mask loss.\n\n During inference, the model requires only the input tensors, and returns the post-processed\n predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as\n follows:\n - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with values between\n ``0`` and ``H`` and ``0`` and ``W``\n - labels (``Int64Tensor[N]``): the predicted labels for each image\n - scores (``Tensor[N]``): the scores or each prediction\n - masks (``UInt8Tensor[N, 1, H, W]``): the predicted masks for each instance, in ``0-1`` range. In order to\n obtain the final segmentation masks, the soft masks can be thresholded, generally\n with a value of 0.5 (``mask >= 0.5``)\n\n Example::\n\n >>> model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)\n >>> model.eval()\n >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]\n >>> predictions = model(x)\n\n Arguments:\n pretrained (bool): If True, returns a model pre-trained on COCO train2017\n progress (bool): If True, displays a progress bar of the download to stderr\n \"\"\"\n if pretrained:\n # no need to download the backbone if pretrained is set\n pretrained_backbone = False\n backbone = resnet_fpn_backbone('resnet50', pretrained_backbone)\n model = MaskRCNN(backbone, num_classes, **kwargs)\n if pretrained:\n state_dict = load_state_dict_from_url(model_urls['maskrcnn_resnet50_fpn_coco'],\n progress=progress)\n model.load_state_dict(state_dict)\n return model\n",
"# Copyright (c) 2020, NVIDIA CORPORATION. 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# Copyright 2021 Huawei Technologies Co., Ltd\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 tensorflow as tf\n\n\ndef apply_transforms(x, y, mean, stdev, transforms):\n for _t in transforms:\n if _t is not None:\n x, y = _t(x, y, mean, stdev)\n return x, y\n\n\ndef apply_test_transforms(x, mean, stdev, transforms):\n for _t in transforms:\n if _t is not None:\n x = _t(x, y=None, mean=mean, stdev=stdev)\n return x\n\n\nclass PadXYZ:\n def __init__(self, shape=None):\n self.shape = shape\n\n def __call__(self, x, y, mean, stdev):\n paddings = tf.constant([[0, 0], [0, 0], [0, 5], [0, 0]])\n x = tf.pad(x, paddings, \"CONSTANT\")\n if y is None:\n return x\n y = tf.pad(y, paddings, \"CONSTANT\")\n return x, y\n\n\nclass CenterCrop:\n def __init__(self, shape):\n self.shape = shape\n\n def __call__(self, x, y, mean, stdev):\n shape = x.get_shape()\n delta = [(shape[i].value - self.shape[i]) // 2 for i in range(len(self.shape))]\n x = x[\n delta[0]:delta[0] + self.shape[0],\n delta[1]:delta[1] + self.shape[1],\n delta[2]:delta[2] + self.shape[2]\n ]\n if y is None:\n return x\n y = y[\n delta[0]:delta[0] + self.shape[0],\n delta[1]:delta[1] + self.shape[1],\n delta[2]:delta[2] + self.shape[2]\n ]\n return x, y\n\n\nclass RandomCrop3D:\n def __init__(self, shape, margins=(0, 0, 0)):\n self.shape = shape\n self.margins = margins\n\n def __call__(self, x, y, mean, stdev):\n shape = x.get_shape()\n min = tf.constant(self.margins, dtype=tf.float32)\n max = tf.constant([shape[0].value - self.shape[0] - self.margins[0],\n shape[1].value - self.shape[1] - self.margins[1],\n shape[2].value - self.shape[2] - self.margins[2]], dtype=tf.float32)\n center = tf.random_uniform((len(self.shape),), minval=min, maxval=max)\n center = tf.cast(center, dtype=tf.int32)\n x = x[center[0]:center[0] + self.shape[0],\n center[1]:center[1] + self.shape[1],\n center[2]:center[2] + self.shape[2]]\n # for NPU\n x.set_shape((128,128,128,4))\n # for NPU\n if y is None:\n return x\n y = y[center[0]:center[0] + self.shape[0],\n center[1]:center[1] + self.shape[1],\n center[2]:center[2] + self.shape[2]]\n # for NPU\n y.set_shape((128, 128, 128))\n # for NPU\n return x, y\n\n\nclass NormalizeImages:\n def __init__(self):\n pass\n\n def __call__(self, x, y, mean, stdev):\n mask = tf.math.greater(x, 0)\n x = tf.where(mask, (x - tf.cast(mean, x.dtype)) / (tf.cast(stdev + 1e-8, x.dtype)), x)\n\n if y is None:\n return x\n return x, y\n\n\nclass Cast:\n def __init__(self, dtype=tf.float32):\n self._dtype = dtype\n\n def __call__(self, x, y, mean, stdev):\n if y is None:\n return tf.cast(x, dtype=self._dtype)\n return tf.cast(x, dtype=self._dtype), y\n\n\nclass RandomHorizontalFlip:\n def __init__(self, threshold=0.5):\n self._threshold = threshold\n\n def __call__(self, x, y, mean, stdev):\n h_flip = tf.random_uniform([]) > self._threshold\n\n x = tf.cond(h_flip, lambda: tf.reverse(x, axis=[1]), lambda: x)\n y = tf.cond(h_flip, lambda: tf.reverse(y, axis=[1]), lambda: y)\n\n return x, y\n\n\nclass RandomVerticalFlip:\n def __init__(self, threshold=0.5):\n self._threshold = threshold\n\n def __call__(self, x, y, mean, stdev):\n h_flip = tf.random_uniform([]) > self._threshold\n\n x = tf.cond(h_flip, lambda: tf.reverse(x, axis=[0]), lambda: x)\n y = tf.cond(h_flip, lambda: tf.reverse(y, axis=[0]), lambda: y)\n\n return x, y\n\n\nclass RandomGammaCorrection:\n def __init__(self, gamma_range=(0.8, 1.5), keep_stats=False, threshold=0.5, epsilon=1e-8):\n self._gamma_range = gamma_range\n self._keep_stats = keep_stats\n self._eps = epsilon\n self._threshold = threshold\n\n def __call__(self, x, y, mean, stdev):\n augment = tf.random_uniform([]) > self._threshold\n gamma = tf.random_uniform([], minval=self._gamma_range[0], maxval=self._gamma_range[1])\n\n x_min = tf.math.reduce_min(x)\n x_range = tf.math.reduce_max(x) - x_min\n\n x = tf.cond(augment,\n lambda: tf.math.pow(((x - x_min) / float(x_range + self._eps)), gamma) * x_range + x_min,\n lambda: x)\n return x, y\n\n\nclass RandomBrightnessCorrection:\n def __init__(self, alpha=0.1, threshold=0.5, per_channel=True):\n self._alpha_range = [1.0 - alpha, 1.0 + alpha]\n self._threshold = threshold\n self._per_channel = per_channel\n\n def __call__(self, x, y, mean, stdev):\n mask = tf.math.greater(x, 0)\n size = x.get_shape()[-1].value if self._per_channel else 1\n augment = tf.random_uniform([]) > self._threshold\n correction = tf.random_uniform([size],\n minval=self._alpha_range[0],\n maxval=self._alpha_range[1],\n dtype=x.dtype)\n\n x = tf.cond(augment,\n lambda: tf.where(mask, x + correction, x),\n lambda: x)\n\n return x, y\n\n\nclass OneHotLabels:\n def __init__(self, n_classes=1):\n self._n_classes = n_classes\n\n def __call__(self, x, y, mean, stdev):\n return x, tf.one_hot(y, self._n_classes)\n\n\nclass PadXY:\n def __init__(self, dst_size=None):\n if not dst_size:\n raise ValueError(\"Invalid padding size: {}\".format(dst_size))\n\n self._dst_size = dst_size\n\n def __call__(self, x, y, mean, stdev):\n return tf.pad(x, self._build_padding(x)), \\\n tf.pad(y, self._build_padding(y))\n\n def _build_padding(self, _t):\n padding = []\n for i in range(len(_t.shape)):\n if i < len(self._dst_size):\n padding.append((0, self._dst_size[i] - _t.shape[i]))\n else:\n padding.append((0, 0))\n return padding\n",
"# -*- coding: utf-8 -*-\n# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\n# Copyright 2020 Huawei Technologies Co., Ltd\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 contextlib\nimport logging\nimport numpy as np\nimport time\nimport weakref\nimport torch\nfrom apex import amp\n\nimport detectron2.utils.comm as comm\nfrom detectron2.utils.events import EventStorage\n\n__all__ = [\"HookBase\", \"TrainerBase\", \"SimpleTrainer\"]\n\n\ntry:\n _nullcontext = contextlib.nullcontext # python 3.7+\nexcept AttributeError:\n\n @contextlib.contextmanager\n def _nullcontext(enter_result=None):\n yield enter_result\n\n\nclass HookBase:\n \"\"\"\n Base class for hooks that can be registered with :class:`TrainerBase`.\n\n Each hook can implement 4 methods. The way they are called is demonstrated\n in the following snippet:\n ::\n hook.before_train()\n for iter in range(start_iter, max_iter):\n hook.before_step()\n trainer.run_step()\n hook.after_step()\n hook.after_train()\n\n Notes:\n 1. In the hook method, users can access `self.trainer` to access more\n properties about the context (e.g., current iteration).\n\n 2. A hook that does something in :meth:`before_step` can often be\n implemented equivalently in :meth:`after_step`.\n If the hook takes non-trivial time, it is strongly recommended to\n implement the hook in :meth:`after_step` instead of :meth:`before_step`.\n The convention is that :meth:`before_step` should only take negligible time.\n\n Following this convention will allow hooks that do care about the difference\n between :meth:`before_step` and :meth:`after_step` (e.g., timer) to\n function properly.\n\n Attributes:\n trainer: A weak reference to the trainer object. Set by the trainer when the hook is\n registered.\n \"\"\"\n\n def before_train(self):\n \"\"\"\n Called before the first iteration.\n \"\"\"\n pass\n\n def after_train(self):\n \"\"\"\n Called after the last iteration.\n \"\"\"\n pass\n\n def before_step(self):\n \"\"\"\n Called before each iteration.\n \"\"\"\n pass\n\n def after_step(self):\n \"\"\"\n Called after each iteration.\n \"\"\"\n pass\n\n\nclass TrainerBase:\n \"\"\"\n Base class for iterative trainer with hooks.\n\n The only assumption we made here is: the training runs in a loop.\n A subclass can implement what the loop is.\n We made no assumptions about the existence of dataloader, optimizer, model, etc.\n\n Attributes:\n iter(int): the current iteration.\n\n start_iter(int): The iteration to start with.\n By convention the minimum possible value is 0.\n\n max_iter(int): The iteration to end training.\n\n storage(EventStorage): An EventStorage that's opened during the course of training.\n \"\"\"\n\n def __init__(self):\n self._hooks = []\n\n def register_hooks(self, hooks):\n \"\"\"\n Register hooks to the trainer. The hooks are executed in the order\n they are registered.\n\n Args:\n hooks (list[Optional[HookBase]]): list of hooks\n \"\"\"\n hooks = [h for h in hooks if h is not None]\n for h in hooks:\n assert isinstance(h, HookBase)\n # To avoid circular reference, hooks and trainer cannot own each other.\n # This normally does not matter, but will cause memory leak if the\n # involved objects contain __del__:\n # See http://engineering.hearsaysocial.com/2013/06/16/circular-references-in-python/\n h.trainer = weakref.proxy(self)\n self._hooks.extend(hooks)\n\n def train(self, start_iter: int, max_iter: int):\n \"\"\"\n Args:\n start_iter, max_iter (int): See docs above\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.info(\"Starting training from iteration {}\".format(start_iter))\n\n self.iter = self.start_iter = start_iter\n self.max_iter = max_iter\n\n with EventStorage(start_iter) as self.storage:\n try:\n self.before_train()\n for self.iter in range(start_iter, max_iter):\n\n self.before_step()\n self.run_step()\n self.after_step()\n\n except Exception:\n logger.exception(\"Exception during training:\")\n raise\n finally:\n self.after_train()\n\n def before_train(self):\n for h in self._hooks:\n h.before_train()\n\n def after_train(self):\n for h in self._hooks:\n h.after_train()\n\n def before_step(self):\n for h in self._hooks:\n h.before_step()\n\n def after_step(self):\n for h in self._hooks:\n h.after_step()\n # this guarantees, that in each hook's after_step, storage.iter == trainer.iter\n self.storage.step()\n\n def run_step(self):\n raise NotImplementedError\n\n\nclass SimpleTrainer(TrainerBase):\n \"\"\"\n A simple trainer for the most common type of task:\n single-cost single-optimizer single-data-source iterative optimization.\n It assumes that every step, you:\n\n 1. Compute the loss with a data from the data_loader.\n 2. Compute the gradients with the above loss.\n 3. Update the model with the optimizer.\n\n All other tasks during training (checkpointing, logging, evaluation, LR schedule)\n are maintained by hooks, which can be registered by :meth:`TrainerBase.register_hooks`.\n\n If you want to do anything fancier than this,\n either subclass TrainerBase and implement your own `run_step`,\n or write your own training loop.\n \"\"\"\n\n def __init__(self, model, data_loader, optimizer, aspect_ratio_grouping=False):\n \"\"\"\n Args:\n model: a torch Module. Takes a data from data_loader and returns a\n dict of losses.\n data_loader: an iterable. Contains data to be used to call model.\n optimizer: a torch optimizer.\n \"\"\"\n super().__init__()\n\n \"\"\"\n We set the model to training mode in the trainer.\n However it's valid to train a model that's in eval mode.\n If you want your model (or a submodule of it) to behave\n like evaluation during training, you can overwrite its train() method.\n \"\"\"\n model.train()\n self.aspect_ratio_grouping = aspect_ratio_grouping\n self.model = model\n self.data_loader = data_loader\n if self.aspect_ratio_grouping:\n self._data_loader_iter = iter(data_loader)\n self.optimizer = optimizer\n\n def run_step(self):\n \"\"\"\n Implement the standard training logic described above.\n \"\"\"\n assert self.model.training, \"[SimpleTrainer] model was changed to eval mode!\"\n start = time.perf_counter()\n \"\"\"\n If you want to do something with the data, you can wrap the dataloader.\n \"\"\"\n if self.aspect_ratio_grouping:\n data=next(self._data_loader_iter)\n else:\n data = self.data_loader.next()\n data_time = time.perf_counter() - start\n\n \"\"\"\n If you want to do something with the losses, you can wrap the model.\n \"\"\"\n loss_dict = self.model(data)\n losses = sum(loss_dict.values())\n\n \"\"\"\n If you need to accumulate gradients or do something similar, you can\n wrap the optimizer with your custom `zero_grad()` method.\n \"\"\"\n self.optimizer.zero_grad()\n if self.cfg.AMP:\n with amp.scale_loss(losses, self.optimizer) as scaled_loss:\n scaled_loss.backward()\n else:\n losses.backward()\n\n # use a new stream so the ops don't wait for DDP\n with torch.cuda.stream(\n torch.cuda.Stream()\n ) if losses.device.type == \"cuda\" else _nullcontext():\n metrics_dict = loss_dict\n metrics_dict[\"data_time\"] = data_time\n self._write_metrics(metrics_dict)\n self._detect_anomaly(losses, loss_dict)\n\n \"\"\"\n If you need gradient clipping/scaling or other processing, you can\n wrap the optimizer with your custom `step()` method. But it is\n suboptimal as explained in https://arxiv.org/abs/2006.15704 Sec 3.2.4\n \"\"\"\n self.optimizer.step()\n\n def _detect_anomaly(self, losses, loss_dict):\n if not torch.isfinite(losses).all():\n raise FloatingPointError(\n \"Loss became infinite or NaN at iteration={}!\\nloss_dict = {}\".format(\n self.iter, loss_dict\n )\n )\n\n def _write_metrics(self, metrics_dict: dict):\n \"\"\"\n Args:\n metrics_dict (dict): dict of scalar metrics\n \"\"\"\n metrics_dict = {\n k: v.detach().cpu().item() if isinstance(v, torch.Tensor) else float(v)\n for k, v in metrics_dict.items()\n }\n # gather metrics among all workers for logging\n # This assumes we do DDP-style training, which is currently the only\n # supported method in detectron2.\n all_metrics_dict = comm.gather(metrics_dict)\n\n if comm.is_main_process():\n if \"data_time\" in all_metrics_dict[0]:\n # data_time among workers can have high variance. The actual latency\n # caused by data_time is the maximum among workers.\n data_time = np.max([x.pop(\"data_time\") for x in all_metrics_dict])\n self.storage.put_scalar(\"data_time\", data_time)\n\n # average the rest metrics\n metrics_dict = {\n k: np.mean([x[k] for x in all_metrics_dict]) for k in all_metrics_dict[0].keys()\n }\n total_losses_reduced = sum(loss for loss in metrics_dict.values())\n\n self.storage.put_scalar(\"total_loss\", total_losses_reduced)\n if len(metrics_dict) > 1:\n self.storage.put_scalars(**metrics_dict)\n",
"# Copyright 2020 Huawei Technologies Co., Ltd\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 torch\nimport timm\nfrom timm.models import create_model, safe_model_name, resume_checkpoint, load_checkpoint,\\\n convert_splitbn_model, model_parameters\nimport torch.onnx\n\nfrom collections import OrderedDict\n\n\ndef proc_node_module(checkpoint, AttrName):\n new_state_dict = OrderedDict()\n for k, v in checkpoint[AttrName].items():\n if(k[0:7] == \"module.\"):\n name = k[7:]\n else:\n name = k[0:]\n new_state_dict[name] = v\n return new_state_dict\n\n\ndef convert():\n checkpoint = torch.load(\"./model_best.pth.tar\", map_location='cpu')\n checkpoint['state_dict'] = proc_node_module(checkpoint, 'state_dict')\n model = timm.create_model('spnasnet_100',pretrained=True)\n model.load_state_dict(checkpoint['state_dict'])\n model.eval()\n print(model)\n\n input_names = [\"actual_input_1\"]\n output_names = [\"output1\"]\n dummy_input = torch.randn(16, 3, 224, 224)\n torch.onnx.export(model, dummy_input, \"spnasnet_100_npu_16.onnx\", input_names=input_names, output_names=output_names,\n opset_version=11)\n\n\nif __name__ == \"__main__\":\n convert()\n",
"# Copyright (c) Soumith Chintala 2016,\n# All rights reserved.\n#\n# Copyright 2020 Huawei Technologies Co., Ltd\n#\n# Licensed under the BSD 3-Clause License (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://spdx.org/licenses/BSD-3-Clause.html\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 argparse\nimport glob\nimport numpy as np\nimport os\nimport random\nimport shutil\nimport sys\nimport time\nimport warnings\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.nn.parallel\nimport torch.backends.cudnn as cudnn\nimport torch.distributed as dist\nimport torch.optim\nimport torch.multiprocessing as mp\nimport torch.utils.data\nimport torch.utils.data.distributed\nimport torchvision.transforms as transforms\nimport torchvision.datasets as datasets\n\nfrom apex import amp\nimport moxing as mox\nimport torch.npu\n\nsys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)), '../'))\n\nfrom hook import forward_hook_fn\nfrom hook import backward_hook_fn\nfrom mobilenet import mobilenet_v2\nfrom pthtar2onnx import convert\n\n\nparser = argparse.ArgumentParser(description='PyTorch ImageNet Training')\nparser.add_argument('--data', metavar='DIR', default='/dataset/imagenet',\n help='path to dataset')\nparser.add_argument('-j', '--workers', default=128, type=int, metavar='N',\n help='number of data loading workers (default: 4)')\nparser.add_argument('--epochs', default=600, type=int, metavar='N',\n help='number of total epochs to run')\nparser.add_argument('--start-epoch', default=0, type=int, metavar='N',\n help='manual epoch number (useful on restarts)')\nparser.add_argument('-b', '--batch-size', default=512, type=int,\n metavar='N',\n help='mini-batch size (default: 256), this is the total '\n 'batch size of all GPUs on the current node when '\n 'using Data Parallel or Distributed Data Parallel')\nparser.add_argument('--lr', '--learning-rate', default=0.05, type=float,\n metavar='LR', help='initial learning rate', dest='lr')\nparser.add_argument('--momentum', default=0.9, type=float, metavar='M',\n help='momentum')\nparser.add_argument('--wd', '--weight-decay', default=1e-5, type=float,\n metavar='W', help='weight decay (default: 1e-4)',\n dest='weight_decay')\nparser.add_argument('-p', '--print-freq', default=1, type=int,\n metavar='N', help='print frequency (default: 10)')\nparser.add_argument('--resume', default='', type=str, metavar='PATH',\n help='path to latest checkpoint (default: none)')\nparser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',\n help='evaluate model on validation set')\nparser.add_argument('--pretrain', default='', type=str, metavar='PATH',\n help='path to pretrain model')\nparser.add_argument('--world-size', default=-1, type=int,\n help='number of nodes for distributed training')\nparser.add_argument('--rank', default=-1, type=int,\n help='node rank for distributed training')\nparser.add_argument('--dist-url', default=None, type=str,\n help='url used to set up distributed training')\nparser.add_argument('--dist-backend', default='nccl', type=str,\n help='distributed backend')\nparser.add_argument('--seed', default=49, type=int,\n help='seed for initializing training. ')\nparser.add_argument('--gpu', default=None, type=int,\n help='GPU id to use.')\nparser.add_argument('--multiprocessing-distributed', action='store_true',\n help='Use multi-processing distributed training to launch '\n 'N processes per node, which has N GPUs. This is the '\n 'fastest way to use PyTorch for either single node or '\n 'multi node data parallel training')\n\nparser.add_argument('--amp', default=False, action='store_true',\n help='use amp to train the model')\nparser.add_argument('--opt-level', default=\"O2\", type=str, help='apex optimize level')\nparser.add_argument('--loss-scale-value', default='64', type=int, help='static loss scale value')\n\nparser.add_argument('--summary-path', default=None, type=str, help='event file path')\nparser.add_argument('--stop-step-num', default=None, type=int, help='after the stop-step, killing the training task')\nparser.add_argument('--device', default='npu:0', type=str, help='device type, cpu or npu:x or cuda:x')\nparser.add_argument('--eval-freq', default=5, type=int, help='test interval')\nparser.add_argument('--hook', default=False, action='store_true', help='pytorch hook')\nparser.add_argument('--class_nums', default=1000, type=int, help='class-nums only for pretrain')\n\n# modelarts modification\nparser.add_argument('--train_url',\n default=\"/cache/training\",\n type=str,\n help=\"setting dir of training output\")\nparser.add_argument('--data_url',\n metavar='DIR',\n default='/cache/data_url',\n help='path to dataset')\nparser.add_argument('--onnx', default=True, action='store_true',\n help=\"convert pth model to onnx\")\n\nCACHE_MODEL_URL = \"/cache/model\"\n\nbest_acc1 = 0\ncur_step = 0\n\nCACHE_TRAINING_URL = \"/cache/training/\"\n\ndef seed_everything(seed, device):\n random.seed(seed)\n os.environ['PYTHONHASHSEED'] = str(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n if 'cuda' in device:\n torch.cuda.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n cudnn.deterministic = True\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\n\ndef main():\n args = parser.parse_args()\n\n if args.seed is not None:\n seed_everything(args.seed, args.device)\n\n warnings.warn('You have chosen to seed training. '\n 'This will turn on the CUDNN deterministic setting, '\n 'which can slow down your training considerably! '\n 'You may see unexpected behavior when restarting '\n 'from checkpoints.')\n\n main_worker(args)\n\n\ndef main_worker(args):\n global best_acc1\n global cur_step\n\n global_step = -1\n\n if 'npu' in args.device:\n torch.npu.set_device(args.device)\n if 'cuda' in args.device:\n torch.cuda.set_device(args.device)\n\n model = mobilenet_v2(num_classes=args.class_nums)\n\n # set hook\n if args.hook:\n modules = model.named_modules()\n for name, module in modules:\n module.register_forward_hook(forward_hook_fn)\n module.register_backward_hook(backward_hook_fn)\n\n optimizer = torch.optim.SGD(model.parameters(), args.lr,\n momentum=args.momentum,\n weight_decay=args.weight_decay)\n\n criterion = nn.CrossEntropyLoss()\n\n if 'npu' in args.device or 'cuda' in args.device:\n model = model.to(args.device)\n criterion = criterion.to(args.device)\n\n if args.amp:\n model, optimizer = amp.initialize(model, optimizer, opt_level=args.opt_level, loss_scale=args.loss_scale_value)\n\n # optionally resume from a checkpoint\n if args.resume:\n if os.path.isfile(args.resume):\n print(\"=> loading checkpoint '{}'\".format(args.resume))\n checkpoint = torch.load(args.resume, map_location=args.device)\n args.start_epoch = checkpoint['epoch']\n best_acc1 = checkpoint['best_acc1']\n model.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n if args.amp:\n amp.load_state_dict(checkpoint['amp'])\n print(\"=> loaded checkpoint '{}' (epoch {})\"\n .format(args.resume, checkpoint['epoch']))\n else:\n print(\"=> no checkpoint found at '{}'\".format(args.resume))\n\n if args.pretrain:\n # ------------------modelarts modification----------------------\n os.makedirs(CACHE_MODEL_URL, exist_ok=True)\n mox.file.copy_parallel(args.pretrain, os.path.join(CACHE_MODEL_URL, \"checkpoint.pth\"))\n # ------------------modelarts modification---------------------\n args.pretrain = os.path.join(CACHE_MODEL_URL, \"checkpoint.pth\")\n if not os.path.isfile(args.pretrain):\n print(\"no chechpoint found at {}\".format(args.pretrain))\n\n print(\"loading checkpoint '{}'\".format(args.pretrain))\n pretrained_dict = torch.load(args.pretrain, map_location=\"cpu\")['state_dict']\n pretrained_dict.pop('module.classifier.1.weight')\n pretrained_dict.pop('module.classifier.1.bias')\n model.load_state_dict(pretrained_dict, strict=False)\n print(\"loaded checkpoint '{}'\".format(args.pretrain))\n\n # Data loading code\n # -------modelarts modification-------\n real_path = '/cache/data_url'\n if not os.path.exists(real_path):\n os.makedirs(real_path)\n mox.file.copy_parallel(args.data_url, real_path)\n print(\"training data finish copy to %s.\" % real_path)\n # ---------modelarts modification-----\n\n traindir = os.path.join(real_path, 'train')\n valdir = os.path.join(real_path, 'val')\n\n normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n\n train_dataset = datasets.ImageFolder(\n traindir,\n transforms.Compose([\n transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n normalize,\n ]))\n\n train_sampler = None\n\n train_loader = torch.utils.data.DataLoader(\n train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None),\n num_workers=args.workers, pin_memory=True, sampler=train_sampler, drop_last=True)\n\n val_loader = torch.utils.data.DataLoader(\n datasets.ImageFolder(valdir, transforms.Compose([\n transforms.Resize(256),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n normalize,\n ])),\n batch_size=args.batch_size, shuffle=False,\n num_workers=args.workers, pin_memory=True, drop_last=True)\n\n if args.evaluate:\n validate(val_loader, model, criterion, args, global_step)\n return\n\n for epoch in range(args.start_epoch, args.epochs):\n\n # train for one epoch\n global_step = train(train_loader, model, criterion, optimizer, epoch, args, global_step)\n\n if (epoch + 1) % args.eval_freq == 0 or epoch == args.epochs - 1:\n # evaluate on validation set\n acc1 = validate(val_loader, model, criterion, args, global_step)\n\n # remember best acc@1 and save checkpoint\n is_best = acc1 > best_acc1\n best_acc1 = max(acc1, best_acc1)\n\n # save checkpoint\n if args.amp:\n save_checkpoint({\n 'epoch': epoch + 1,\n 'state_dict': model.state_dict(),\n 'best_acc1': best_acc1,\n 'optimizer': optimizer.state_dict(),\n 'amp': amp.state_dict(),\n }, is_best)\n else:\n save_checkpoint({\n 'epoch': epoch + 1,\n 'state_dict': model.state_dict(),\n 'best_acc1': best_acc1,\n 'optimizer': optimizer.state_dict(),\n }, is_best)\n\n if args.stop_step_num is not None and cur_step >= args.stop_step_num:\n break\n\n if args.onnx:\n convert_pth_to_onnx(args)\n\n # --------------modelarts modification----------\n mox.file.copy_parallel(CACHE_TRAINING_URL, args.train_url)\n # --------------modelarts modification end----------\n\n\ndef convert_pth_to_onnx(args):\n pth_pattern = os.path.join(CACHE_TRAINING_URL, 'checkpoint.pth.tar')\n pth_file_list = glob.glob(pth_pattern)\n if not pth_file_list:\n print(f\"can't find pth {pth_pattern}\")\n return\n pth_file = pth_file_list[0]\n onnx_path = pth_file.split(\".\")[0] + '.onnx'\n convert(pth_file, onnx_path, args.class_nums)\n\n\ndef train(train_loader, model, criterion, optimizer, epoch, args, global_step, sum_writer=None):\n global cur_step\n\n if args.seed is not None:\n seed_everything(args.seed + epoch, args.device)\n\n batch_time = AverageMeter('Time', ':6.3f')\n data_time = AverageMeter('Data', ':6.3f')\n learning_rate = AverageMeter('LR', ':2.8f')\n losses = AverageMeter('Loss', ':6.8f')\n top1 = AverageMeter('Acc@1', ':6.2f')\n top5 = AverageMeter('Acc@5', ':6.2f')\n progress = ProgressMeter(\n len(train_loader),\n [batch_time, data_time, learning_rate, losses, top1, top5],\n prefix=\"Epoch: [{}]\".format(epoch))\n\n # switch to train mode\n model.train()\n\n end = time.time()\n steps_per_epoch = len(train_loader)\n for i, (images, target) in enumerate(train_loader):\n\n global_step = epoch * steps_per_epoch + i\n cur_step = global_step\n\n lr = adjust_learning_rate(optimizer, global_step, steps_per_epoch, args)\n\n learning_rate.update(lr)\n\n # measure data loading time\n data_time.update(time.time() - end)\n\n if 'npu' in args.device:\n target = target.to(torch.int32)\n\n if 'npu' in args.device or 'cuda' in args.device:\n images = images.to(args.device, non_blocking=True)\n target = target.to(args.device, non_blocking=True)\n\n # compute output\n output = model(images)\n loss = criterion(output, target)\n\n # measure accuracy and record loss\n acc1, acc5 = accuracy(output, target, topk=(1, 5))\n losses.update(loss.item(), images.size(0))\n top1.update(acc1[0], images.size(0))\n top5.update(acc5[0], images.size(0))\n\n # compute gradient and do SGD step\n optimizer.zero_grad()\n if args.amp:\n with amp.scale_loss(loss, optimizer) as scaled_loss:\n scaled_loss.backward()\n else:\n loss.backward()\n\n optimizer.step()\n\n # measure elapsed time\n batch_time.update(time.time() - end)\n end = time.time()\n\n if i % args.print_freq == 0:\n progress.display(i)\n\n if args.stop_step_num is not None and cur_step >= args.stop_step_num:\n break\n\n print(' * FPS@all {:.3f}'.format(args.batch_size / (batch_time.avg + 0.001)))\n return global_step\n\n\ndef validate(val_loader, model, criterion, args, global_step, sum_writer=None):\n batch_time = AverageMeter('Time', ':6.3f')\n losses = AverageMeter('Loss', ':.4e')\n top1 = AverageMeter('Acc@1', ':6.2f')\n top5 = AverageMeter('Acc@5', ':6.2f')\n progress = ProgressMeter(\n len(val_loader),\n [batch_time, losses, top1, top5],\n prefix='Test: ')\n\n # switch to evaluate mode\n model.eval()\n\n with torch.no_grad():\n end = time.time()\n for i, (images, target) in enumerate(val_loader):\n\n if 'npu' in args.device:\n target = target.to(torch.int32)\n\n if 'npu' in args.device or 'cuda' in args.device:\n images = images.to(args.device, non_blocking=True)\n target = target.to(args.device, non_blocking=True)\n\n # compute output\n output = model(images)\n loss = criterion(output, target)\n\n # measure accuracy and record loss\n acc1, acc5 = accuracy(output, target, topk=(1, 5))\n losses.update(loss.item(), images.size(0))\n top1.update(acc1[0], images.size(0))\n top5.update(acc5[0], images.size(0))\n\n # measure elapsed time\n batch_time.update(time.time() - end)\n end = time.time()\n\n if i % args.print_freq == 0:\n progress.display(i)\n\n # TODO: this should also be done with the ProgressMeter\n print(' * Acc@1 {top1.avg:.3f} Acc@5 {top5.avg:.3f}'\n .format(top1=top1, top5=top5))\n\n return top1.avg\n\n\ndef save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):\n args = parser.parse_args()\n\n if not os.path.exists(CACHE_TRAINING_URL):\n os.makedirs(CACHE_TRAINING_URL)\n\n checkpoint_save_path = os.path.join(CACHE_TRAINING_URL, filename)\n torch.save(state, checkpoint_save_path)\n if is_best:\n shutil.copyfile(checkpoint_save_path, os.path.join(CACHE_TRAINING_URL, \"model_best.pth.tar\"))\n\n\nclass AverageMeter(object):\n \"\"\"Computes and stores the average and current value\"\"\"\n def __init__(self, name, fmt=':f'):\n self.name = name\n self.fmt = fmt\n self.reset()\n self.start_count_index = 10\n\n def reset(self):\n self.val = 0\n self.avg = 0\n self.sum = 0\n self.count = 0\n\n def update(self, val, n=1):\n if self.count == 0:\n self.batchsize = n\n\n self.val = val\n self.count += n\n if self.count > (self.start_count_index * self.batchsize):\n self.sum += val * n\n self.avg = self.sum / (self.count - self.start_count_index * self.batchsize)\n\n def __str__(self):\n fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})'\n return fmtstr.format(**self.__dict__)\n\n\nclass ProgressMeter(object):\n def __init__(self, num_batches, meters, prefix=\"\"):\n self.batch_fmtstr = self._get_batch_fmtstr(num_batches)\n self.meters = meters\n self.prefix = prefix\n\n def display(self, batch):\n entries = [self.prefix + self.batch_fmtstr.format(batch)]\n entries += [str(meter) for meter in self.meters]\n print('\\t'.join(entries))\n\n def _get_batch_fmtstr(self, num_batches):\n num_digits = len(str(num_batches // 1))\n fmt = '{:' + str(num_digits) + 'd}'\n return '[' + fmt + '/' + fmt.format(num_batches) + ']'\n\n\ndef adjust_learning_rate(optimizer, global_step, steps_per_epoch, args):\n \"\"\"Sets the learning rate to the initial LR decayed by 10 every 30 epochs\"\"\"\n # lr = args.lr * (0.98 ** (epoch / 2.5))\n lr = args.lr * (0.98 ** (global_step // int(steps_per_epoch * 2.5)))\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr\n return lr\n\n\ndef accuracy(output, target, topk=(1,)):\n \"\"\"Computes the accuracy over the k top predictions for the specified values of k\"\"\"\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res\n\n\nif __name__ == '__main__':\n main()\n",
"#! -*- coding:utf-8 -*-\n# Copyright 2020 Huawei Technologies Co., Ltd\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 __future__ import division, print_function\n\nimport tensorflow as tf\nimport numpy as np\nimport argparse\nfrom tensorflow.core.protobuf.rewriter_config_pb2 import RewriterConfig\nimport npu_bridge\nimport json\nimport os,time\nimport collections\nfrom pycocotools.coco import COCO\nfrom pycocotools.cocoeval import COCOeval\n\nRAW_SHAPE = \"raw_shape\"\nIS_PADDED = \"is_padded\"\nSOURCE_ID = \"source_id\"\nMIN_SCORE = 0.05\nDUMMY_SCORE = -1e5\nMAX_NUM_EVAL_BOXES = 200\nOVERLAP_CRITERIA = 0.5\nCLASS_INV_MAP = (\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21,\n 22, 23, 24, 25, 27, 28, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,\n 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n 64, 65, 67, 70, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 86, 87,\n 88, 89, 90)\n\ndef parse_args():\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument('--batch_size', default=1,\n help=\"\"\"batchsize\"\"\")\n parser.add_argument('--model_path', default='ssd-resnet34_1batch.pb',\n help=\"\"\"pb path\"\"\")\n parser.add_argument('--data_path', default = 'coco2017/val2017',\n help = \"\"\"the data path\"\"\")\n parser.add_argument('--val_json_file', default='coco_official_2017/annotations/instances_val2017.json',\n help=\"\"\"the val json file path\"\"\")\n parser.add_argument('--input_tensor_name', default='input:0',\n help=\"\"\"the output1 tensor name\"\"\")\n parser.add_argument('--output_tensor_name1', default='Softmax:0',\n help=\"\"\"the output1 tensor name\"\"\")\n parser.add_argument('--output_tensor_name2', default='stack:0',\n help=\"\"\"the output2 tensor name\"\"\")\n\n\n args, unknown_args = parser.parse_known_args()\n if len(unknown_args) > 0:\n for bad_arg in unknown_args:\n print(\"ERROR: Unknown command line arg: %s\" % bad_arg)\n raise ValueError(\"Invalid command line arg(s)\")\n return args\n\n\ndef load_model(model_file):\n with tf.gfile.GFile(model_file, \"rb\") as gf:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(gf.read())\n\n with tf.Graph().as_default() as graph:\n tf.import_graph_def(graph_def, name=\"\")\n\n return graph\n\ndef top_k(input, k=1, sorted=True):\n \"\"\"Top k max pooling\n Args:\n input(ndarray): convolutional feature in heigh x width x channel format\n k(int): if k==1, it is equal to normal max pooling\n sorted(bool): whether to return the array sorted by channel value\n Returns:\n ndarray: k x (height x width)\n ndarray: k\n \"\"\"\n ind = np.argpartition(input, -k)[..., -k:]\n def get_entries(input, ind, sorted):\n if len(ind.shape) == 1:\n if sorted:\n ind = ind[np.argsort(-input[ind])]\n return input[ind], ind\n output, ind = zip(*[get_entries(inp, id, sorted) for inp, id in zip(input, ind)])\n return np.array(output), np.array(ind)\n return get_entries(input, ind, sorted)\n\ndef select_top_k_scores(scores_in, pre_nms_num_detections=5000):\n '''\n scores_trans = tf.transpose(scores_in, perm=[0, 2, 1])\n top_k_scores, top_k_indices = tf.nn.top_k(\n scores_trans, k=pre_nms_num_detections, sorted=True)\n return tf.transpose(top_k_scores, [0, 2, 1]), tf.transpose(\n top_k_indices, [0, 2, 1])\n '''\n scores_trans = np.transpose(scores_in, (0, 2, 1))\n top_k_scores, top_k_indices = top_k(scores_trans, k = pre_nms_num_detections)\n return np.transpose(top_k_scores, (0, 2, 1)), np.transpose(top_k_indices, (0, 2, 1))\n\n\ndef _load_images_info(images_info_file):\n \"\"\"Loads object annotation JSON file.\"\"\"\n f = open(images_info_file, encoding='utf-8')\n info_dict = json.load(f)\n\n img_to_obj_annotation = collections.defaultdict(list)\n for annotation in info_dict['annotations']:\n image_id = annotation['image_id']\n img_to_obj_annotation[image_id].append(annotation)\n return info_dict['images'],img_to_obj_annotation\n\ndef get_image_obj(images_info_file, input_images):\n f = open(images_info_file, encoding='utf-8')\n info_dict = json.load(f)\n img_obj = collections.defaultdict(list)\n img_info_list = []\n image_list_new = []\n for image in info_dict['images']:\n img_info = {}\n image_name = image['file_name']\n if image_name not in input_images:\n continue\n img_info['source_id'] = image['id']\n img_info['raw_shape'] = [image['height'], image['width'], 3]\n img_info_list.append(img_info)\n image_list_new.append(image_name)\n\n return img_info_list, image_list_new\n\n\ndef _read_inputImage(filename):\n image_list = []\n if os.path.isdir(filename):\n for file in os.listdir(filename):\n file = file.split('.')[0] + \".jpg\"\n image_list.append(file)\n return image_list\n\n\ndef image_process(image_path, images_name):\n ###image process\n imagelist = []\n images_count = 0\n for image_name in images_name:\n with tf.Session().as_default():\n #with tf.Session() as sess:\n image_file = os.path.join(image_path, image_name)\n image = tf.gfile.FastGFile(image_file, 'rb').read()\n image = tf.image.decode_jpeg(image, channels=3)\n image = tf.image.resize_images(image, size=(300, 300))\n image /= 255.\n images_count = images_count + 1\n if tf.shape(image)[2].eval() == 1:\n image = tf.image.grayscale_to_rgb(image)\n image = image.eval()\n imagelist.append(image)\n tf.reset_default_graph()\n return np.array(imagelist), images_count\n\nclass Classifier(object):\n # set batch_size\n args = parse_args()\n batch_size = int(args.batch_size)\n\n def __init__(self):\n # --------------------------------------------------------------------------------\n config = tf.ConfigProto()\n custom_op = config.graph_options.rewrite_options.custom_optimizers.add()\n custom_op.name = \"NpuOptimizer\"\n # 1）run on Ascend NPU\n custom_op.parameter_map[\"use_off_line\"].b = True\n\n # 2）recommended use fp16 datatype to obtain better performance\n custom_op.parameter_map[\"precision_mode\"].s = tf.compat.as_bytes(\"force_fp16\")\n\n # 3）disable remapping\n config.graph_options.rewrite_options.remapping = RewriterConfig.OFF\n\n # 4）set graph_run_mode=0，obtain better performance\n custom_op.parameter_map[\"graph_run_mode\"].i = 0\n # --------------------------------------------------------------------------------\n\n # load model， set graph input nodes and output nodes\n args = parse_args()\n self.graph = self.__load_model(args.model_path)\n self.input_tensor = self.graph.get_tensor_by_name(args.input_tensor_name)\n self.output_tensor1 = self.graph.get_tensor_by_name(args.output_tensor_name1)\n self.output_tensor2 = self.graph.get_tensor_by_name(args.output_tensor_name2)\n\n # create session\n self.sess = tf.Session(config=config, graph=self.graph)\n\n def __load_model(self, model_file):\n \"\"\"\n load fronzen graph\n :param model_file:\n :return:\n \"\"\"\n with tf.gfile.GFile(model_file, \"rb\") as gf:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(gf.read())\n\n with tf.Graph().as_default() as graph:\n tf.import_graph_def(graph_def, name=\"\")\n\n return graph\n\n def infer(self, batch_size, batch_data, labels_list, images_count):\n dataOutput = []\n total_time = 0\n count = 0\n for data in batch_data:\n t = time.time()\n classes, boxes = self.sess.run([self.output_tensor1, self.output_tensor2], feed_dict={self.input_tensor: data.reshape(int(batch_size),300,300,3)})\n total_time = total_time + time.time() - t\n pred_scores, indices = select_top_k_scores(classes,200)\n output_index = 0\n while output_index < int(batch_size) and count < images_count:\n dataOutput.append({\"pred_box\": boxes[output_index],\n \"source_id\": labels_list[count]['source_id'],\n \"indices\": indices[output_index],\n \"pred_scores\": pred_scores[output_index],\n \"raw_shape\": labels_list[count]['raw_shape']})\n output_index = output_index + 1\n count = count + 1\n\n return dataOutput, total_time\n\n def batch_process(self, image_data):\n \"\"\"\n images preprocess\n :return:\n \"\"\"\n # Get the batch information of the current input data, and automatically adjust the data to the fixed batch\n n_dim = image_data.shape[0]\n batch_size = self.batch_size\n\n # if data is not enough for the whole batch, you need to complete the data\n m = n_dim % batch_size\n if m < batch_size and m > 0:\n # The insufficient part shall be filled with 0 according to n dimension\n pad = np.zeros((batch_size - m, 300, 300, 3)).astype(np.float32)\n image_data = np.concatenate((image_data, pad), axis=0)\n\n # Define the Minis that can be divided into several batches\n mini_batch = []\n i = 0\n while i < n_dim:\n # Define the Minis that can be divided into several batches\n mini_batch.append(image_data[i: i + batch_size, :, :, :])\n i += batch_size\n\n return mini_batch\n\ndef decode_single(bboxes_in,\n scores_in,\n indices,\n criteria,\n max_output,\n max_num=200):\n \"\"\"Implement Non-maximum suppression.\n\n Reference to https://github.com/amdegroot/ssd.pytorch\n\n Args:\n bboxes_in: a Tensor with shape [N, 4], which stacks box regression outputs\n on all feature levels. The N is the number of total anchors on all levels.\n scores_in: a Tensor with shape [ssd_constants.MAX_NUM_EVAL_BOXES,\n num_classes]. The top ssd_constants.MAX_NUM_EVAL_BOXES box scores for each\n class.\n indices: a Tensor with shape [ssd_constants.MAX_NUM_EVAL_BOXES,\n num_classes]. The indices for these top boxes for each class.\n criteria: a float number to specify the threshold of NMS.\n max_output: maximum output length.\n max_num: maximum number of boxes before NMS.\n\n Returns:\n boxes, labels and scores after NMS.\n \"\"\"\n\n bboxes_out = []\n scores_out = []\n labels_out = []\n\n for i, score in enumerate(np.split(scores_in, scores_in.shape[1], 1)):\n class_indices = indices[:, i]\n bboxes = bboxes_in[class_indices, :]\n score = np.squeeze(score, 1)\n\n # skip background\n if i == 0:\n continue\n\n mask = score > MIN_SCORE\n if not np.any(mask):\n continue\n\n bboxes, score = bboxes[mask, :], score[mask]\n\n # remain_list = []\n # for r in range(bboxes.shape[0]):\n # if bboxes[r, 0] < 0 or bboxes[r, 1] < 0 or bboxes[r, 2] < 0 or bboxes[r, 3] < 0 or bboxes[r, 0] >= bboxes[r, 2] or \\\n # bboxes[r, 1] >= bboxes[r, 3]:\n # continue\n # remain_list.append(r)\n # bboxes = bboxes[remain_list, :]\n # score = score[remain_list]\n\n remain_list = []\n for r in range(bboxes.shape[0]):\n for j in range(4):\n if bboxes[r, j] < 0:\n bboxes[r, j] = 0.00001\n if bboxes[r, 0] >= bboxes[r, 2]:\n bboxes[r, 2] = bboxes[r, 0] + 0.00001\n if bboxes[r, 1] >= bboxes[r, 3]:\n bboxes[r, 3] = bboxes[r, 1] + 0.00001\n remain_list.append(r)\n bboxes = bboxes[remain_list, :]\n score = score[remain_list]\n\n\n score_idx_sorted = np.argsort(score)\n score_sorted = score[score_idx_sorted]\n\n score_idx_sorted = score_idx_sorted[-max_num:]\n candidates = []\n\n # perform non-maximum suppression\n while len(score_idx_sorted):\n idx = score_idx_sorted[-1]\n bboxes_sorted = bboxes[score_idx_sorted, :]\n bboxes_idx = bboxes[idx, :]\n iou = calc_iou(bboxes_idx, bboxes_sorted)\n\n score_idx_sorted = score_idx_sorted[iou < criteria]\n candidates.append(idx)\n\n bboxes_out.append(bboxes[candidates, :])\n scores_out.append(score[candidates])\n labels_out.extend([i]*len(candidates))\n\n if len(scores_out) == 0:\n tf.logging.info(\"No objects detected. Returning dummy values.\")\n return (\n np.zeros(shape=(1, 4), dtype=np.float32),\n np.zeros(shape=(1,), dtype=np.int32),\n np.ones(shape=(1,), dtype=np.float32) * DUMMY_SCORE,\n )\n\n bboxes_out = np.concatenate(bboxes_out, axis=0)\n scores_out = np.concatenate(scores_out, axis=0)\n labels_out = np.array(labels_out)\n\n max_ids = np.argsort(scores_out)[-max_output:]\n\n return bboxes_out[max_ids, :], labels_out[max_ids], scores_out[max_ids]\n\ndef calc_iou(target, candidates):\n target_tiled = np.tile(target[np.newaxis, :], (candidates.shape[0], 1))\n # Left Top & Right Bottom\n lt = np.maximum(target_tiled[:,:2], candidates[:,:2])\n\n rb = np.minimum(target_tiled[:,2:], candidates[:,2:])\n\n delta = np.maximum(rb - lt, 0)\n\n intersect = delta[:,0] * delta[:,1]\n\n delta1 = target_tiled[:, 2:] - target_tiled[:, :2]\n area1 = delta1[:,0] * delta1[:,1]\n delta2 = candidates[:, 2:] - candidates[:, :2]\n area2 = delta2[:,0] * delta2[:,1]\n\n iou = intersect/(area1 + area2 - intersect)\n return iou\n\ndef compute_map(labels_and_predictions,\n coco_gt,\n use_cpp_extension=True,\n nms_on_tpu=True):\n \"\"\"Use model predictions to compute mAP.\n\n The evaluation code is largely copied from the MLPerf reference\n implementation. While it is possible to write the evaluation as a tensor\n metric and use Estimator.evaluate(), this approach was selected for simplicity\n and ease of duck testing.\n\n Args:\n labels_and_predictions: A map from TPU predict method.\n coco_gt: ground truch COCO object.\n use_cpp_extension: use cocoeval C++ library.\n nms_on_tpu: do NMS on TPU.\n Returns:\n Evaluation result.\n \"\"\"\n predictions = []\n tic = time.time()\n\n if nms_on_tpu:\n p = []\n for i in labels_and_predictions:\n for j in i:\n p.append(np.array(j, dtype=np.float32))\n predictions = np.concatenate(list(p)).reshape((-1, 7))\n else:\n k = 0\n for example in labels_and_predictions:\n if IS_PADDED in example and example[\n IS_PADDED]:\n continue\n #print(k)\n k += 1\n htot, wtot, _ = example[RAW_SHAPE]\n pred_box = example['pred_box']\n pred_scores = example['pred_scores']\n indices = example['indices']\n loc, label, prob = decode_single(\n pred_box, pred_scores, indices, OVERLAP_CRITERIA,\n MAX_NUM_EVAL_BOXES, MAX_NUM_EVAL_BOXES)\n\n for loc_, label_, prob_ in zip(loc, label, prob):\n # Ordering convention differs, hence [1], [0] rather than [0], [1]\n predictions.append([\n int(example[SOURCE_ID]),\n loc_[1] * wtot, loc_[0] * htot, (loc_[3] - loc_[1]) * wtot,\n (loc_[2] - loc_[0]) * htot, prob_,\n CLASS_INV_MAP[label_]\n ])\n\n toc = time.time()\n tf.logging.info('Prepare predictions DONE (t={:0.2f}s).'.format(toc - tic))\n\n if coco_gt is None:\n coco_gt = create_coco(\n FLAGS.val_json_file, use_cpp_extension=use_cpp_extension)\n\n if use_cpp_extension:\n coco_dt = coco_gt.LoadRes(np.array(predictions, dtype=np.float32))\n coco_eval = COCOeval(coco_gt, coco_dt, iou_type='bbox')\n coco_eval.Evaluate()\n coco_eval.Accumulate()\n coco_eval.Summarize()\n stats = coco_eval.GetStats()\n\n else:\n coco_dt = coco_gt.loadRes(np.array(predictions))\n\n coco_eval = COCOeval(coco_gt, coco_dt, iouType='bbox')\n coco_eval.evaluate()\n coco_eval.accumulate()\n coco_eval.summarize()\n stats = coco_eval.stats\n\n print('Current AP: {:.5f}'.format(stats[0]))\n metric_names = ['AP', 'AP50', 'AP75', 'APs', 'APm', 'APl', 'ARmax1',\n 'ARmax10', 'ARmax100', 'ARs', 'ARm', 'ARl']\n coco_time = time.time()\n tf.logging.info('COCO eval DONE (t={:0.2f}s).'.format(coco_time - toc))\n\n # Prefix with \"COCO\" to group in TensorBoard.\n return {'COCO/' + key: value for key, value in zip(metric_names, stats)}\n\n\ndef create_coco(val_json_file, use_cpp_extension=True):\n \"\"\"Creates Microsoft COCO helper class object and return it.\"\"\"\n if val_json_file.startswith('gs://'):\n _, local_val_json = tempfile.mkstemp(suffix='.json')\n tf.gfile.Remove(local_val_json)\n\n tf.gfile.Copy(val_json_file, local_val_json)\n atexit.register(tf.gfile.Remove, local_val_json)\n else:\n local_val_json = val_json_file\n\n if use_cpp_extension:\n coco_gt = coco.COCO(local_val_json, False)\n else:\n coco_gt = COCO(local_val_json)\n return coco_gt\n\ndef main():\n args = parse_args()\n tf.reset_default_graph()\n\n image_list = _read_inputImage(args.data_path)\n image_obj, image_list = get_image_obj(args.val_json_file, image_list)\n\n print(\"########NOW Start Preprocess!!!#########\")\n images, images_count = image_process(args.data_path, image_list)\n\n ###batch\n print(\"########NOW Start Batch!!!#########\")\n classifier = Classifier()\n batch_images = classifier.batch_process(images)\n\n ###do inference\n print(\"########NOW Start inference!!!#########\")\n dataOutput, total_time = classifier.infer(args.batch_size, batch_images, image_obj, images_count)\n\n coco_gt = create_coco(\n args.val_json_file, use_cpp_extension=False)\n compute_map(\n dataOutput,\n coco_gt,\n use_cpp_extension=False,\n nms_on_tpu=False)\n\n print('+-------------------------------------------------+')\n print('images number = ', images_count)\n print('images/sec = ', images_count / total_time)\n print('+-------------------------------------------------+')\n\nif __name__ == '__main__':\n main()\n",
"# Copyright 2016 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# ============================================================================\n# Copyright 2021 Huawei Technologies Co., Ltd\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\"\"\"Contains definitions for the preactivation form of Residual Networks.\n\nResidual networks (ResNets) were originally proposed in:\n[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun\n Deep Residual Learning for Image Recognition. arXiv:1512.03385\n\nThe full preactivation 'v2' ResNet variant implemented in this module was\nintroduced by:\n[2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun\n Identity Mappings in Deep Residual Networks. arXiv: 1603.05027\n\nThe key difference of the full preactivation 'v2' variant compared to the\n'v1' variant in [1] is the use of batch normalization before every weight layer.\n\nTypical use:\n\n from tensorflow.contrib.slim.nets import resnet_v2\n\nResNet-101 for image classification into 1000 classes:\n\n # inputs has shape [batch, 224, 224, 3]\n with slim.arg_scope(resnet_v2.resnet_arg_scope()):\n net, end_points = resnet_v2.resnet_v2_101(inputs, 1000, is_training=False)\n\nResNet-101 for semantic segmentation into 21 classes:\n\n # inputs has shape [batch, 513, 513, 3]\n with slim.arg_scope(resnet_v2.resnet_arg_scope()):\n net, end_points = resnet_v2.resnet_v2_101(inputs,\n 21,\n is_training=False,\n global_pool=False,\n output_stride=16)\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport tensorflow as tf\nfrom tensorflow.contrib import slim as contrib_slim\n\nfrom nets import resnet_utils\n\nslim = contrib_slim\nresnet_arg_scope = resnet_utils.resnet_arg_scope\n\n\[email protected]_arg_scope\ndef bottleneck(inputs, depth, depth_bottleneck, stride, rate=1,\n outputs_collections=None, scope=None):\n \"\"\"Bottleneck residual unit variant with BN before convolutions.\n\n This is the full preactivation residual unit variant proposed in [2]. See\n Fig. 1(b) of [2] for its definition. Note that we use here the bottleneck\n variant which has an extra bottleneck layer.\n\n When putting together two consecutive ResNet blocks that use this unit, one\n should use stride = 2 in the last unit of the first block.\n\n Args:\n inputs: A tensor of size [batch, height, width, channels].\n depth: The depth of the ResNet unit output.\n depth_bottleneck: The depth of the bottleneck layers.\n stride: The ResNet unit's stride. Determines the amount of downsampling of\n the units output compared to its input.\n rate: An integer, rate for atrous convolution.\n outputs_collections: Collection to add the ResNet unit output.\n scope: Optional variable_scope.\n\n Returns:\n The ResNet unit's output.\n \"\"\"\n with tf.compat.v1.variable_scope(scope, 'bottleneck_v2', [inputs]) as sc:\n depth_in = slim.utils.last_dimension(inputs.get_shape(), min_rank=4)\n preact = slim.batch_norm(inputs, activation_fn=tf.nn.relu, scope='preact')\n if depth == depth_in:\n shortcut = resnet_utils.subsample(inputs, stride, 'shortcut')\n else:\n shortcut = slim.conv2d(preact, depth, [1, 1], stride=stride,\n normalizer_fn=None, activation_fn=None,\n scope='shortcut')\n\n residual = slim.conv2d(preact, depth_bottleneck, [1, 1], stride=1,\n scope='conv1')\n residual = resnet_utils.conv2d_same(residual, depth_bottleneck, 3, stride,\n rate=rate, scope='conv2')\n residual = slim.conv2d(residual, depth, [1, 1], stride=1,\n normalizer_fn=None, activation_fn=None,\n scope='conv3')\n\n output = shortcut + residual\n\n return slim.utils.collect_named_outputs(outputs_collections,\n sc.name,\n output)\n\n\ndef resnet_v2(inputs,\n blocks,\n num_classes=None,\n is_training=True,\n global_pool=True,\n output_stride=None,\n include_root_block=True,\n spatial_squeeze=True,\n reuse=None,\n scope=None):\n \"\"\"Generator for v2 (preactivation) ResNet models.\n\n This function generates a family of ResNet v2 models. See the resnet_v2_*()\n methods for specific model instantiations, obtained by selecting different\n block instantiations that produce ResNets of various depths.\n\n Training for image classification on Imagenet is usually done with [224, 224]\n inputs, resulting in [7, 7] feature maps at the output of the last ResNet\n block for the ResNets defined in [1] that have nominal stride equal to 32.\n However, for dense prediction tasks we advise that one uses inputs with\n spatial dimensions that are multiples of 32 plus 1, e.g., [321, 321]. In\n this case the feature maps at the ResNet output will have spatial shape\n [(height - 1) / output_stride + 1, (width - 1) / output_stride + 1]\n and corners exactly aligned with the input image corners, which greatly\n facilitates alignment of the features to the image. Using as input [225, 225]\n images results in [8, 8] feature maps at the output of the last ResNet block.\n\n For dense prediction tasks, the ResNet needs to run in fully-convolutional\n (FCN) mode and global_pool needs to be set to False. The ResNets in [1, 2] all\n have nominal stride equal to 32 and a good choice in FCN mode is to use\n output_stride=16 in order to increase the density of the computed features at\n small computational and memory overhead, cf. http://arxiv.org/abs/1606.00915.\n\n Args:\n inputs: A tensor of size [batch, height_in, width_in, channels].\n blocks: A list of length equal to the number of ResNet blocks. Each element\n is a resnet_utils.Block object describing the units in the block.\n num_classes: Number of predicted classes for classification tasks.\n If 0 or None, we return the features before the logit layer.\n is_training: whether batch_norm layers are in training mode.\n global_pool: If True, we perform global average pooling before computing the\n logits. Set to True for image classification, False for dense prediction.\n output_stride: If None, then the output will be computed at the nominal\n network stride. If output_stride is not None, it specifies the requested\n ratio of input to output spatial resolution.\n include_root_block: If True, include the initial convolution followed by\n max-pooling, if False excludes it. If excluded, `inputs` should be the\n results of an activation-less convolution.\n spatial_squeeze: if True, logits is of shape [B, C], if false logits is\n of shape [B, 1, 1, C], where B is batch_size and C is number of classes.\n To use this parameter, the input images must be smaller than 300x300\n pixels, in which case the output logit layer does not contain spatial\n information and can be removed.\n reuse: whether or not the network and its variables should be reused. To be\n able to reuse 'scope' must be given.\n scope: Optional variable_scope.\n\n\n Returns:\n net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].\n If global_pool is False, then height_out and width_out are reduced by a\n factor of output_stride compared to the respective height_in and width_in,\n else both height_out and width_out equal one. If num_classes is 0 or None,\n then net is the output of the last ResNet block, potentially after global\n average pooling. If num_classes is a non-zero integer, net contains the\n pre-softmax activations.\n end_points: A dictionary from components of the network to the corresponding\n activation.\n\n Raises:\n ValueError: If the target output_stride is not valid.\n \"\"\"\n with tf.compat.v1.variable_scope(\n scope, 'resnet_v2', [inputs], reuse=reuse) as sc:\n end_points_collection = sc.original_name_scope + '_end_points'\n with slim.arg_scope([slim.conv2d, bottleneck,\n resnet_utils.stack_blocks_dense],\n outputs_collections=end_points_collection):\n with slim.arg_scope([slim.batch_norm], is_training=is_training):\n net = inputs\n if include_root_block:\n if output_stride is not None:\n if output_stride % 4 != 0:\n raise ValueError('The output_stride needs to be a multiple of 4.')\n output_stride /= 4\n # We do not include batch normalization or activation functions in\n # conv1 because the first ResNet unit will perform these. Cf.\n # Appendix of [2].\n with slim.arg_scope([slim.conv2d],\n activation_fn=None, normalizer_fn=None):\n net = resnet_utils.conv2d_same(net, 64, 7, stride=2, scope='conv1')\n net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')\n net = resnet_utils.stack_blocks_dense(net, blocks, output_stride)\n # This is needed because the pre-activation variant does not have batch\n # normalization or activation functions in the residual unit output. See\n # Appendix of [2].\n net = slim.batch_norm(net, activation_fn=tf.nn.relu, scope='postnorm')\n # Convert end_points_collection into a dictionary of end_points.\n end_points = slim.utils.convert_collection_to_dict(\n end_points_collection)\n\n if global_pool:\n # Global average pooling.\n net = tf.reduce_mean(\n input_tensor=net, axis=[1, 2], name='pool5', keepdims=True)\n end_points['global_pool'] = net\n if num_classes:\n net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,\n normalizer_fn=None, scope='logits')\n end_points[sc.name + '/logits'] = net\n if spatial_squeeze:\n net = tf.squeeze(net, [1, 2], name='SpatialSqueeze')\n end_points[sc.name + '/spatial_squeeze'] = net\n end_points['predictions'] = slim.softmax(net, scope='predictions')\n return net, end_points\nresnet_v2.default_image_size = 224\n\n\ndef resnet_v2_block(scope, base_depth, num_units, stride):\n \"\"\"Helper function for creating a resnet_v2 bottleneck block.\n\n Args:\n scope: The scope of the block.\n base_depth: The depth of the bottleneck layer for each unit.\n num_units: The number of units in the block.\n stride: The stride of the block, implemented as a stride in the last unit.\n All other units have stride=1.\n\n Returns:\n A resnet_v2 bottleneck block.\n \"\"\"\n return resnet_utils.Block(scope, bottleneck, [{\n 'depth': base_depth * 4,\n 'depth_bottleneck': base_depth,\n 'stride': 1\n }] * (num_units - 1) + [{\n 'depth': base_depth * 4,\n 'depth_bottleneck': base_depth,\n 'stride': stride\n }])\nresnet_v2.default_image_size = 224\n\n\ndef resnet_v2_50(inputs,\n num_classes=None,\n is_training=True,\n global_pool=True,\n output_stride=None,\n spatial_squeeze=True,\n reuse=None,\n scope='resnet_v2_50'):\n \"\"\"ResNet-50 model of [1]. See resnet_v2() for arg and return description.\"\"\"\n blocks = [\n resnet_v2_block('block1', base_depth=64, num_units=3, stride=2),\n resnet_v2_block('block2', base_depth=128, num_units=4, stride=2),\n resnet_v2_block('block3', base_depth=256, num_units=6, stride=2),\n resnet_v2_block('block4', base_depth=512, num_units=3, stride=1),\n ]\n return resnet_v2(inputs, blocks, num_classes, is_training=is_training,\n global_pool=global_pool, output_stride=output_stride,\n include_root_block=True, spatial_squeeze=spatial_squeeze,\n reuse=reuse, scope=scope)\nresnet_v2_50.default_image_size = resnet_v2.default_image_size\n\n\ndef resnet_v2_101(inputs,\n num_classes=None,\n is_training=True,\n global_pool=True,\n output_stride=None,\n spatial_squeeze=True,\n reuse=None,\n scope='resnet_v2_101'):\n \"\"\"ResNet-101 model of [1]. See resnet_v2() for arg and return description.\"\"\"\n blocks = [\n resnet_v2_block('block1', base_depth=64, num_units=3, stride=2),\n resnet_v2_block('block2', base_depth=128, num_units=4, stride=2),\n resnet_v2_block('block3', base_depth=256, num_units=23, stride=2),\n resnet_v2_block('block4', base_depth=512, num_units=3, stride=1),\n ]\n return resnet_v2(inputs, blocks, num_classes, is_training=is_training,\n global_pool=global_pool, output_stride=output_stride,\n include_root_block=True, spatial_squeeze=spatial_squeeze,\n reuse=reuse, scope=scope)\nresnet_v2_101.default_image_size = resnet_v2.default_image_size\n\n\ndef resnet_v2_152(inputs,\n num_classes=None,\n is_training=True,\n global_pool=True,\n output_stride=None,\n spatial_squeeze=True,\n reuse=None,\n scope='resnet_v2_152'):\n \"\"\"ResNet-152 model of [1]. See resnet_v2() for arg and return description.\"\"\"\n blocks = [\n resnet_v2_block('block1', base_depth=64, num_units=3, stride=2),\n resnet_v2_block('block2', base_depth=128, num_units=8, stride=2),\n resnet_v2_block('block3', base_depth=256, num_units=36, stride=2),\n resnet_v2_block('block4', base_depth=512, num_units=3, stride=1),\n ]\n return resnet_v2(inputs, blocks, num_classes, is_training=is_training,\n global_pool=global_pool, output_stride=output_stride,\n include_root_block=True, spatial_squeeze=spatial_squeeze,\n reuse=reuse, scope=scope)\nresnet_v2_152.default_image_size = resnet_v2.default_image_size\n\n\ndef resnet_v2_200(inputs,\n num_classes=None,\n is_training=True,\n global_pool=True,\n output_stride=None,\n spatial_squeeze=True,\n reuse=None,\n scope='resnet_v2_200'):\n \"\"\"ResNet-200 model of [2]. See resnet_v2() for arg and return description.\"\"\"\n blocks = [\n resnet_v2_block('block1', base_depth=64, num_units=3, stride=2),\n resnet_v2_block('block2', base_depth=128, num_units=24, stride=2),\n resnet_v2_block('block3', base_depth=256, num_units=36, stride=2),\n resnet_v2_block('block4', base_depth=512, num_units=3, stride=1),\n ]\n return resnet_v2(inputs, blocks, num_classes, is_training=is_training,\n global_pool=global_pool, output_stride=output_stride,\n include_root_block=True, spatial_squeeze=spatial_squeeze,\n reuse=reuse, scope=scope)\nresnet_v2_200.default_image_size = resnet_v2.default_image_size\n"
] | [
[
"torch.zeros_like"
],
[
"sklearn.metrics.average_precision_score",
"sklearn.metrics.roc_auc_score"
],
[
"numpy.fromfile"
],
[
"torch.save",
"torch.load"
],
[
"torch.is_grad_enabled",
"torch.nn.parallel.distributed._find_tensors"
],
[
"numpy.concatenate",
"torch.sigmoid",
"numpy.max",
"numpy.empty",
"torch.no_grad",
"numpy.mean",
"torch.sign",
"numpy.where",
"torch.utils.data.DataLoader",
"torch.load",
"torch.npu.set_device",
"torch.npu.synchronize"
],
[
"torch.nn.Conv2d",
"torch.nn.functional.avg_pool2d"
],
[
"numpy.array",
"numpy.minimum"
],
[
"tensorflow.image.random_hue",
"tensorflow.data.TFRecordDataset",
"tensorflow.ones",
"tensorflow.logical_not",
"tensorflow.reshape",
"tensorflow.data.experimental.parallel_interleave",
"tensorflow.stack",
"tensorflow.tile",
"tensorflow.greater",
"tensorflow.cast",
"tensorflow.shape",
"tensorflow.concat",
"tensorflow.less",
"tensorflow.random_uniform",
"tensorflow.image.random_brightness",
"tensorflow.squeeze",
"tensorflow.pad",
"tensorflow.data.Options",
"tensorflow.string_to_number",
"numpy.array",
"tensorflow.range",
"tensorflow.minimum",
"tensorflow.data.Dataset.list_files",
"tensorflow.zeros",
"tensorflow.expand_dims",
"tensorflow.to_int64",
"tensorflow.name_scope",
"numpy.clip",
"tensorflow.image.resize_images",
"tensorflow.boolean_mask",
"tensorflow.image.random_saturation",
"tensorflow.convert_to_tensor",
"tensorflow.random_shuffle",
"tensorflow.not_equal",
"tensorflow.reduce_any",
"tensorflow.image.random_contrast",
"tensorflow.reduce_max",
"tensorflow.gather",
"tensorflow.maximum"
],
[
"tensorflow.constant_initializer",
"tensorflow.compat.as_bytes",
"tensorflow.control_dependencies",
"tensorflow.global_variables_initializer",
"tensorflow.cast",
"tensorflow.no_op",
"tensorflow.trainable_variables",
"tensorflow.train.latest_checkpoint",
"tensorflow.concat",
"tensorflow.get_default_graph",
"tensorflow.global_variables",
"tensorflow.ConfigProto",
"tensorflow.gfile.DeleteRecursively",
"tensorflow.get_variable_scope",
"tensorflow.gfile.MkDir",
"tensorflow.app.run",
"tensorflow.get_collection",
"tensorflow.train.AdamOptimizer",
"tensorflow.summary.scalar",
"tensorflow.expand_dims",
"tensorflow.gfile.Exists",
"tensorflow.Session",
"tensorflow.placeholder",
"tensorflow.name_scope",
"tensorflow.contrib.slim.get_trainable_variables",
"tensorflow.summary.merge_all",
"tensorflow.train.exponential_decay",
"tensorflow.scalar_mul",
"tensorflow.summary.image",
"tensorflow.app.flags.DEFINE_integer",
"numpy.isnan",
"tensorflow.app.flags.DEFINE_string",
"tensorflow.app.flags.DEFINE_boolean",
"tensorflow.app.flags.DEFINE_float",
"tensorflow.train.ExponentialMovingAverage",
"tensorflow.reduce_mean"
],
[
"numpy.finfo"
],
[
"tensorflow.Session",
"tensorflow.reset_default_graph",
"tensorflow.placeholder",
"tensorflow.train.Saver"
],
[
"torch.Tensor"
],
[
"torch.nn.functional.sigmoid",
"torch.save",
"torch.nn.parallel.DistributedDataParallel",
"torch.nn.BCELoss",
"torch.npu.set_device",
"torch.npu.is_available",
"torch.load"
],
[
"torch.zeros_like",
"torch.max"
],
[
"numpy.array",
"numpy.asarray",
"numpy.zeros",
"numpy.all",
"matplotlib.pyplot.show",
"matplotlib.pyplot.imshow"
],
[
"numpy.array"
],
[
"numpy.concatenate",
"torch.distributed.get_world_size",
"numpy.array",
"numpy.zeros",
"torch.distributed.destroy_process_group",
"numpy.random.seed",
"torch.distributed.init_process_group",
"torch.nn.functional.interpolate",
"numpy.ones",
"torch.nn.parallel.DistributedDataParallel",
"numpy.interp",
"numpy.loadtxt",
"torch.optim.lr_scheduler.LambdaLR",
"torch.distributed.get_rank",
"torch.distributed.broadcast"
],
[
"numpy.array"
],
[
"tensorflow.image.random_flip_left_right",
"numpy.rollaxis",
"tensorflow.reshape",
"tensorflow.stack",
"tensorflow.cast",
"tensorflow.shape",
"tensorflow.image.decode_and_crop_jpeg",
"tensorflow.image.sample_distorted_bounding_box",
"tensorflow.constant",
"numpy.expand_dims",
"tensorflow.minimum",
"tensorflow.image.convert_image_dtype",
"tensorflow.Session",
"tensorflow.placeholder",
"tensorflow.name_scope",
"tensorflow.reduce_sum",
"tensorflow.unstack",
"tensorflow.equal",
"tensorflow.device",
"tensorflow.image.extract_jpeg_shape",
"tensorflow.image.resize"
],
[
"torch.nn.ReLU",
"torch.nn.init.kaiming_normal_"
],
[
"tensorflow.where",
"tensorflow.math.reduce_min",
"tensorflow.random_uniform",
"tensorflow.reverse",
"tensorflow.constant",
"tensorflow.math.reduce_max",
"tensorflow.math.greater",
"tensorflow.one_hot",
"tensorflow.cast",
"tensorflow.pad"
],
[
"torch.isfinite",
"torch.cuda.Stream",
"numpy.mean"
],
[
"torch.onnx.export",
"torch.randn",
"torch.load"
],
[
"torch.cuda.manual_seed",
"torch.cuda.manual_seed_all",
"numpy.random.seed",
"torch.save",
"torch.no_grad",
"torch.manual_seed",
"torch.cuda.set_device",
"torch.utils.data.DataLoader",
"torch.load",
"torch.npu.set_device",
"torch.nn.CrossEntropyLoss"
],
[
"numpy.minimum",
"tensorflow.compat.as_bytes",
"numpy.tile",
"tensorflow.import_graph_def",
"tensorflow.image.decode_jpeg",
"numpy.concatenate",
"tensorflow.shape",
"tensorflow.gfile.Copy",
"tensorflow.logging.info",
"tensorflow.ConfigProto",
"numpy.transpose",
"numpy.array",
"numpy.zeros",
"tensorflow.GraphDef",
"tensorflow.Session",
"tensorflow.gfile.GFile",
"tensorflow.gfile.FastGFile",
"numpy.argsort",
"tensorflow.image.resize_images",
"numpy.squeeze",
"tensorflow.gfile.Remove",
"tensorflow.Graph",
"tensorflow.reset_default_graph",
"numpy.ones",
"numpy.split",
"numpy.any",
"numpy.argpartition",
"tensorflow.image.grayscale_to_rgb",
"numpy.maximum"
],
[
"tensorflow.squeeze",
"tensorflow.reduce_mean",
"tensorflow.compat.v1.variable_scope"
]
] |
anglixjtu/MeshCNN_ | [
"83826e66d8989ed4967047c2ed6d099568c5781c",
"83826e66d8989ed4967047c2ed6d099568c5781c"
] | [
"src/util/losses.py",
"src/util/visualization.py"
] | [
"import torch\nimport torch.nn as nn\n\n\nclass ChamferLoss(nn.Module):\n\n def __init__(self):\n super(ChamferLoss, self).__init__()\n self.use_cuda = torch.cuda.is_available()\n\n def forward(self, preds, gts, reverse=True, bidirectional=True):\n def compute_loss(preds, gts):\n P = self.batch_pairwise_dist(gts, preds)\n mins, _ = torch.min(P, 1)\n loss_1 = torch.sum(mins)\n mins, _ = torch.min(P, 2)\n loss_2 = torch.sum(mins)\n return loss_1 + loss_2\n\n if bidirectional or reverse:\n backward_loss = compute_loss(gts, preds)\n if reverse:\n return backward_loss\n else:\n forward_loss = compute_loss(preds, gts)\n return forward_loss + backward_loss\n else:\n forward_loss = compute_loss(preds, gts)\n return forward_loss\n\n def batch_pairwise_dist(self, x, y):\n bs, num_points_x, points_dim = x.size()\n _, num_points_y, _ = y.size()\n xx = torch.bmm(x, x.transpose(2, 1))\n yy = torch.bmm(y, y.transpose(2, 1))\n zz = torch.bmm(x, y.transpose(2, 1))\n if self.use_cuda:\n dtype = torch.cuda.LongTensor\n else:\n dtype = torch.LongTensor\n diag_ind_x = torch.arange(0, num_points_x).type(dtype)\n diag_ind_y = torch.arange(0, num_points_y).type(dtype)\n rx = xx[:, diag_ind_x, diag_ind_x].unsqueeze(1).expand_as(\n zz.transpose(2, 1))\n ry = yy[:, diag_ind_y, diag_ind_y].unsqueeze(1).expand_as(zz)\n P = rx.transpose(2, 1) + ry - 2 * zz\n return P",
"import numpy as np\nfrom faiss import IndexFlatIP, IndexFlatL2\nimport pyvista as pv\nimport os\nimport time\nfrom torch_geometric.nn import global_mean_pool, global_add_pool, global_max_pool, global_sort_pool\nimport torch.nn.functional as F\nfrom torch.utils.tensorboard import SummaryWriter\nfrom .util import get_labels_from_path\n\n\ndef add_subplot(plotter, coord_y, coord_x,\n mesh, font_size, label=None,\n dissm=None, filename=None,\n show_edges=True):\n plotter.subplot(coord_y, coord_x)\n\n text = ''\n if label is not None:\n text += label + '\\n'\n if dissm is not None:\n text += \"distance: %.3f \\n\" % (dissm)\n if filename is not None:\n text += filename\n if label or dissm or filename:\n plotter.add_text(text, font_size=font_size, color='black')\n plotter.set_background('white')\n plotter.add_mesh(mesh, color=\"tan\", show_edges=show_edges)\n\n\ndef visualize_retrieval(paths_q, paths_retr, dissm=None, show_self=False,\n sub_size=(220, 150), font_size=10, out_path=None,\n camera_pos=[4, 4, 4]):\n num_query = len(paths_q)\n if show_self:\n start_ri = 0\n else:\n start_ri = 1\n num_retr = len(paths_retr[0][start_ri:])\n num_subplot = (num_query, num_retr+1)\n fig_size = ((num_retr+1)*sub_size[1], num_query*sub_size[0])\n\n p = pv.Plotter(shape=num_subplot,\n window_size=fig_size, border_color='gray')\n for qi, path_q in enumerate(paths_q):\n mesh_q = pv.read(path_q)\n _, filename = os.path.split(path_q)\n label = get_labels_from_path(path_q)\n label = 'Query - ' + label\n add_subplot(p, qi, 0, mesh_q, font_size,\n label=label, filename=filename)\n p.set_position(camera_pos)\n\n for ri, path_r in enumerate(paths_retr[qi][start_ri:]):\n mesh_r = pv.read(path_r)\n _, filename = os.path.split(path_r)\n label = get_labels_from_path(path_r)\n dissm_r = dissm[qi, ri+start_ri]\n add_subplot(p, qi, ri+1, mesh_r,\n font_size, dissm=dissm_r,\n label=label, filename=filename)\n p.set_position(camera_pos)\n p.show(screenshot=out_path)\n\n\ndef show_embedding(self, features, idx_list):\n label_list = self.get_labels_from_index(idx_list)\n writer = SummaryWriter('runs/embedding')\n writer.add_embedding(features,\n metadata=label_list)\n writer.close()\n"
] | [
[
"torch.cuda.is_available",
"torch.min",
"torch.arange",
"torch.sum"
],
[
"torch.utils.tensorboard.SummaryWriter"
]
] |
morkovka1337/openvino_training_extensions | [
"846db45c264d6b061505213f51763520b9432ba9",
"846db45c264d6b061505213f51763520b9432ba9",
"846db45c264d6b061505213f51763520b9432ba9",
"846db45c264d6b061505213f51763520b9432ba9",
"846db45c264d6b061505213f51763520b9432ba9",
"846db45c264d6b061505213f51763520b9432ba9"
] | [
"pytorch_toolkit/nncf/examples/object_detection/layers/modules/multibox_loss.py",
"tensorflow_toolkit/text_recognition/text_recognition/model.py",
"pytorch_toolkit/nncf/tests/modules/test_rnn.py",
"tensorflow_toolkit/ssd_detector/vlp/config.py",
"pytorch_toolkit/nncf/nncf/nncf_network.py",
"tensorflow_toolkit/text_recognition/tools/test.py"
] | [
"\"\"\"\n Copyright (c) 2019 Intel Corporation\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 http://www.apache.org/licenses/LICENSE-2.0\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 torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom ..box_utils import match, log_sum_exp\n\n\nclass MultiBoxLoss(nn.Module):\n \"\"\"SSD Weighted Loss Function\n Compute Targets:\n 1) Produce Confidence Target Indices by matching ground truth boxes\n with (default) 'priorboxes' that have jaccard index > threshold parameter\n (default threshold: 0.5).\n 2) Produce localization target by 'encoding' variance into offsets of ground\n truth boxes and their matched 'priorboxes'.\n 3) Hard negative mining to filter the excessive number of negative examples\n that comes with using a large number of default bounding boxes.\n (default negative:positive ratio 3:1)\n Objective Loss:\n L(x,c,l,g) = (Lconf(x, c) + αLloc(x,l,g)) / N\n Where, Lconf is the CrossEntropy Loss and Lloc is the SmoothL1 Loss\n weighted by α which is set to 1 by cross val.\n Args:\n c: class confidences,\n l: predicted boxes,\n g: ground truth boxes\n N: number of matched default boxes\n See: https://arxiv.org/pdf/1512.02325.pdf for more details.\n \"\"\"\n\n def __init__(self, cfg, num_classes, overlap_thresh, prior_for_matching,\n bkg_label, neg_mining, neg_pos, neg_overlap, encode_target, device=None):\n super(MultiBoxLoss, self).__init__()\n self.device = device\n self.num_classes = num_classes\n self.threshold = overlap_thresh\n self.background_label = bkg_label\n self.encode_target = encode_target\n self.use_prior_for_matching = prior_for_matching\n self.do_neg_mining = neg_mining\n self.negpos_ratio = neg_pos\n self.neg_overlap = neg_overlap\n\n def forward(self, predictions, targets):\n \"\"\"Multibox Loss\n Args:\n predictions (tuple): A tuple containing loc preds, conf preds,\n and prior boxes from SSD net.\n conf shape: torch.size(batch_size,num_priors,num_classes)\n loc shape: torch.size(batch_size,num_priors,4)\n priors shape: torch.size(num_priors,4)\n\n ground_truth (tensor): Ground truth boxes and labels for a batch,\n shape: [batch_size,num_objs,5] (last idx is the label).\n \"\"\"\n loc_data, conf_data, priors = predictions\n batch = loc_data.size(0)\n num_priors = loc_data.size(1)\n\n # match priors (default boxes) and ground truth boxes\n loc_t = torch.Tensor(batch, num_priors, 4).to(self.device)\n conf_t = torch.LongTensor(batch, num_priors).to(self.device)\n for idx in range(batch):\n truths = targets[idx][:, :-1].data\n labels = targets[idx][:, -1].data\n defaults = priors.data\n match(self.threshold, truths, defaults[0], labels, loc_t, conf_t, idx)\n pos = conf_t > 0\n num_pos = pos.sum(dim=1, keepdim=True)\n\n # Localization Loss (Smooth L1)\n # Shape: [batch,num_priors,4]\n pos_idx = pos.unsqueeze(pos.dim()).expand_as(loc_data)\n loc_p = loc_data[pos_idx].view(-1, 4)\n loc_t = loc_t[pos_idx].view(-1, 4)\n loss_l = F.smooth_l1_loss(loc_p, loc_t, reduction='sum')\n\n # Compute max conf across batch for hard negative mining\n batch_conf = conf_data.view(-1, self.num_classes)\n\n loss_c = log_sum_exp(batch_conf) - batch_conf.gather(1, conf_t.view(-1, 1))\n\n # Hard Negative Mining\n loss_c = loss_c.view(batch, -1)\n loss_c[pos] = 0 # filter out pos boxes for now\n _, loss_idx = loss_c.sort(1, descending=True)\n _, idx_rank = loss_idx.sort(1)\n num_pos = pos.long().sum(1, keepdim=True)\n num_neg = torch.clamp(self.negpos_ratio * num_pos, max=pos.size(1) - 1)\n neg = idx_rank < num_neg.expand_as(idx_rank)\n\n # Confidence Loss Including Positive and Negative Examples\n pos_idx = pos.unsqueeze(2).expand_as(conf_data)\n neg_idx = neg.unsqueeze(2).expand_as(conf_data)\n conf_p = conf_data[(pos_idx + neg_idx).gt(0)].view(-1, self.num_classes)\n targets_weighted = conf_t[(pos + neg).gt(0)]\n loss_c = F.cross_entropy(conf_p, targets_weighted, reduction='sum')\n\n # Sum of losses: L(x,c,l,g) = (Lconf(x, c) + αLloc(x,l,g)) / N\n\n N = num_pos.data.sum().to(torch.float)\n loss_l /= N\n loss_c /= N\n return loss_l, loss_c\n",
"# Copyright (C) 2019 Intel Corporation\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,\n# software 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\n# and limitations under the License.\n\n\"\"\" This module contains architecture of Text Recognition model.\"\"\"\n\nimport tensorflow as tf\nfrom tensorflow.contrib import rnn\nimport tensorflow.contrib.slim as slim\n\n\nclass TextRecognition:\n \"\"\" Text recognition model definition. \"\"\"\n\n def __init__(self, is_training, num_classes, backbone_dropout=0.0):\n self.is_training = is_training\n self.lstm_dim = 256\n self.num_classes = num_classes\n self.backbone_dropout = backbone_dropout\n\n def __call__(self, inputdata):\n with tf.variable_scope('shadow'):\n features = self.feature_extractor(inputdata=inputdata)\n logits = self.encoder_decoder(inputdata=tf.squeeze(features, axis=1))\n\n return logits\n\n # pylint: disable=too-many-locals\n def feature_extractor(self, inputdata):\n \"\"\" Extracts features from input text image. \"\"\"\n\n with slim.arg_scope([slim.conv2d], padding='SAME',\n weights_initializer=tf.contrib.layers.variance_scaling_initializer(),\n weights_regularizer=slim.l2_regularizer(0.00025),\n biases_initializer=None, activation_fn=None):\n with slim.arg_scope([slim.batch_norm], updates_collections=None):\n bn0 = slim.batch_norm(inputdata, 0.9, scale=True, is_training=self.is_training,\n activation_fn=None)\n\n dropout1 = slim.dropout(bn0, keep_prob=1.0 - self.backbone_dropout,\n is_training=self.is_training)\n conv1 = slim.conv2d(dropout1, num_outputs=64, kernel_size=3)\n bn1 = slim.batch_norm(conv1, 0.9, scale=True, is_training=self.is_training,\n activation_fn=tf.nn.relu)\n pool1 = slim.max_pool2d(bn1, kernel_size=2, stride=2)\n\n dropout2 = slim.dropout(pool1, keep_prob=1.0 - self.backbone_dropout,\n is_training=self.is_training)\n conv2 = slim.conv2d(dropout2, num_outputs=128, kernel_size=3)\n bn2 = slim.batch_norm(conv2, 0.9, scale=True, is_training=self.is_training,\n activation_fn=tf.nn.relu)\n pool2 = slim.max_pool2d(bn2, kernel_size=2, stride=2)\n\n dropout3 = slim.dropout(pool2, keep_prob=1.0 - self.backbone_dropout,\n is_training=self.is_training)\n conv3 = slim.conv2d(dropout3, num_outputs=256, kernel_size=3)\n bn3 = slim.batch_norm(conv3, 0.9, scale=True, is_training=self.is_training,\n activation_fn=tf.nn.relu)\n\n dropout4 = slim.dropout(bn3, keep_prob=1.0 - self.backbone_dropout,\n is_training=self.is_training)\n conv4 = slim.conv2d(dropout4, num_outputs=256, kernel_size=3)\n bn4 = slim.batch_norm(conv4, 0.9, scale=True, is_training=self.is_training,\n activation_fn=tf.nn.relu)\n pool4 = slim.max_pool2d(bn4, kernel_size=[2, 1], stride=[2, 1])\n\n dropout5 = slim.dropout(pool4, keep_prob=1.0 - self.backbone_dropout,\n is_training=self.is_training)\n conv5 = slim.conv2d(dropout5, num_outputs=512, kernel_size=3)\n bn5 = slim.batch_norm(conv5, 0.9, scale=True, is_training=self.is_training,\n activation_fn=tf.nn.relu)\n\n dropout6 = slim.dropout(bn5, keep_prob=1.0 - self.backbone_dropout,\n is_training=self.is_training)\n conv6 = slim.conv2d(dropout6, num_outputs=512, kernel_size=3)\n bn6 = slim.batch_norm(conv6, 0.9, scale=True, is_training=self.is_training,\n activation_fn=tf.nn.relu)\n pool6 = slim.max_pool2d(bn6, kernel_size=[2, 1], stride=[2, 1])\n\n dropout7 = slim.dropout(pool6, keep_prob=1.0 - self.backbone_dropout,\n is_training=self.is_training)\n conv7 = slim.conv2d(dropout7, num_outputs=512, kernel_size=2, stride=[2, 1])\n bn7 = slim.batch_norm(conv7, 0.9, scale=True, is_training=self.is_training,\n activation_fn=tf.nn.relu)\n\n return bn7\n\n def encoder_decoder(self, inputdata):\n \"\"\" LSTM-based encoder-decoder module. \"\"\"\n\n with tf.variable_scope('LSTMLayers'):\n [batch_size, width, _] = inputdata.get_shape().as_list()\n\n with tf.variable_scope('encoder'):\n forward_cells = []\n backward_cells = []\n\n for _ in range(2):\n forward_cells.append(tf.nn.rnn_cell.LSTMCell(self.lstm_dim))\n backward_cells.append(tf.nn.rnn_cell.LSTMCell(self.lstm_dim))\n\n encoder_layer, _, _ = rnn.stack_bidirectional_dynamic_rnn(\n forward_cells, backward_cells, inputdata, dtype=tf.float32)\n\n with tf.variable_scope('decoder'):\n forward_cells = []\n backward_cells = []\n\n for _ in range(2):\n forward_cells.append(tf.nn.rnn_cell.LSTMCell(self.lstm_dim))\n backward_cells.append(tf.nn.rnn_cell.LSTMCell(self.lstm_dim))\n\n decoder_layer, _, _ = rnn.stack_bidirectional_dynamic_rnn(\n forward_cells, backward_cells, encoder_layer, dtype=tf.float32)\n\n rnn_reshaped = tf.reshape(decoder_layer, [batch_size * width, -1])\n\n logits = slim.fully_connected(rnn_reshaped, self.num_classes, activation_fn=None)\n logits = tf.reshape(logits, [batch_size, width, self.num_classes])\n rnn_out = tf.transpose(logits, (1, 0, 2))\n\n return rnn_out\n",
"\"\"\"\n Copyright (c) 2019-2020 Intel Corporation\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 http://www.apache.org/licenses/LICENSE-2.0\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 logging\nimport sys\nfrom collections import namedtuple\nfrom typing import List, Tuple\n\nimport copy\nimport onnx\nimport os\nimport pytest\nimport torch\nimport torch.nn.functional as F\nfrom functools import partial\nfrom torch import nn\nfrom torch.autograd import Variable\nfrom torch.nn.utils.rnn import PackedSequence\n\nfrom nncf.dynamic_graph.context import TracingContext\nfrom nncf.dynamic_graph.transform_graph import replace_modules\nfrom nncf.model_creation import create_compressed_model\nfrom nncf.layers import LSTMCellNNCF, NNCF_RNN, ITERATION_MODULES\nfrom tests.modules.seq2seq.gnmt import GNMT\nfrom tests.test_helpers import get_empty_config, get_grads, create_compressed_model_and_algo_for_test\n\n\ndef replace_lstm(model):\n def replace_fn(module_):\n if not isinstance(module_, nn.LSTM):\n return module_\n device = next(module_.parameters()).device\n custom_lstm = NNCF_RNN('LSTM', input_size=module_.input_size, hidden_size=module_.hidden_size,\n num_layers=module_.num_layers, bidirectional=module_.bidirectional,\n batch_first=module_.batch_first, dropout=module_.dropout,\n bias=module_.bias)\n\n def get_param_names(bias):\n # type: (bool) -> List[str]\n suffixes = ['ih', 'hh']\n names = ['weight_' + suffix for suffix in suffixes]\n if bias:\n names += ['bias_' + suffix for suffix in suffixes]\n return names\n\n for l in range(custom_lstm.num_layers):\n for d in range(custom_lstm.num_directions):\n for name in get_param_names(custom_lstm.bias):\n suffix = '_reverse' if d == 1 else ''\n param_name = name + '_l{}{}'.format(l, suffix)\n param = getattr(module_, param_name)\n getattr(custom_lstm, param_name).data.copy_(param.data)\n custom_lstm.to(device)\n return custom_lstm\n\n if isinstance(model, nn.LSTM):\n return replace_fn(model)\n affected_scopes = []\n return replace_modules(model, replace_fn, affected_scopes)[0]\n\ndef clone_test_data(data_list):\n # type: (LSTMTestData) -> List[torch.Tensor]\n results = []\n x = data_list[0]\n result = x if isinstance(x, PackedSequence) else x.clone()\n results.append(result)\n for tensor_list in data_list[1:]:\n result = ()\n for tensor in tensor_list:\n if isinstance(tensor, Variable):\n sub_result = tensor.data.clone()\n sub_result = Variable(sub_result, requires_grad=True)\n else:\n sub_result = tensor.clone()\n result += (sub_result,)\n results.append(result)\n return results\n\n\nLSTMTestSizes = namedtuple('LSTMTestSizes', ['input_size', 'hidden_size', 'batch', 'seq_length'])\nLSTMTestData = namedtuple('LSTMTestData', ['x', 'h0', 'c0', 'weight_ih', 'weight_hh', 'bias_ih', 'bias_hh'])\n\n\[email protected]('sizes',\n [LSTMTestSizes(512, 768, 128, 50),\n LSTMTestSizes(3, 3, 3, 3),\n LSTMTestSizes(1, 1, 1, 1)], ids=lambda val: '[{}]'.format('-'.join([str(v) for v in val])))\nclass TestLSTMCell:\n @staticmethod\n def generate_lstm_data(p, num_layers=1, num_directions=1, variable_length=False, sorted_=True, batch_first=True,\n is_cuda=False, bias=True, empty_initial=False, is_backward=False):\n # type: (LSTMTestSizes, int, int, bool, bool, bool, bool, bool, bool, bool) -> LSTMTestData\n num_chunks = 4\n seq_list = []\n if variable_length:\n seq_lens = torch.IntTensor(p.batch).random_(1, p.seq_length + 1)\n if sorted_:\n seq_lens = torch.sort(seq_lens, descending=True).values\n for seq_size in seq_lens:\n seq_list.append(torch.randn(seq_size.item(), p.input_size))\n padded_seq_batch = torch.nn.utils.rnn.pad_sequence(seq_list, batch_first=batch_first)\n x_data = torch.nn.utils.rnn.pack_padded_sequence(padded_seq_batch, lengths=seq_lens,\n batch_first=batch_first, enforce_sorted=sorted_)\n\n else:\n size = (p.seq_length, p.batch, p.input_size)\n if batch_first:\n size = (p.batch, p.seq_length, p.input_size)\n x_data = torch.randn(*size)\n\n def wrap_tensor(tensor):\n wrapped = tensor\n if is_cuda:\n wrapped = wrapped.cuda()\n if is_backward:\n wrapped = Variable(wrapped, requires_grad=True)\n return wrapped\n\n if is_cuda:\n x_data = x_data.cuda()\n h0, c0, wih, whh, bih, bhh = ([] for _ in range(6))\n for layer_ in range(num_layers):\n for _ in range(num_directions):\n layer_input_size = p.input_size if layer_ == 0 else p.hidden_size * num_directions\n if not empty_initial:\n h0.append(wrap_tensor(torch.randn(p.batch, p.hidden_size)))\n c0.append(wrap_tensor(torch.randn(p.batch, p.hidden_size)))\n wih.append(wrap_tensor(torch.rand(num_chunks * p.hidden_size, layer_input_size)))\n whh.append(wrap_tensor(torch.rand(num_chunks * p.hidden_size, p.hidden_size)))\n if bias:\n bih.append(wrap_tensor(torch.rand(num_chunks * p.hidden_size)))\n bhh.append(wrap_tensor(torch.rand(num_chunks * p.hidden_size)))\n result = LSTMTestData(x_data, h0, c0, wih, whh, bih, bhh)\n return result\n\n @staticmethod\n def set_weights(cell, data):\n # type: (nn.LSTMCell, LSTMTestData) -> None\n for name in TestLSTM.get_param_names(bias=True):\n param = getattr(data, name)\n if param:\n getattr(cell, name).data.copy_(param[0].data)\n\n def test_forward_lstm_cell(self, sizes, _seed):\n p = sizes\n ref_data = TestLSTMCell.generate_lstm_data(p, batch_first=False)\n test_data = LSTMTestData(*clone_test_data(ref_data))\n\n ref_rnn = nn.LSTMCell(p.input_size, p.hidden_size)\n TestLSTMCell.set_weights(ref_rnn, ref_data)\n test_rnn = LSTMCellNNCF(p.input_size, p.hidden_size)\n TestLSTMCell.set_weights(test_rnn, test_data)\n\n for i in range(p.seq_length):\n ref_result = ref_rnn(ref_data.x[i], (ref_data.h0[0], ref_data.c0[0]))\n test_result = test_rnn(test_data.x[i], (test_data.h0[0], test_data.c0[0]))\n for (ref, test) in list(zip(ref_result, test_result)):\n torch.testing.assert_allclose(test, ref)\n\n def test_backward_lstm_cell(self, sizes, _seed):\n p = sizes\n ref_data = TestLSTMCell.generate_lstm_data(p, batch_first=False, is_backward=True)\n with torch.no_grad():\n test_data = LSTMTestData(*clone_test_data(ref_data))\n\n ref_rnn = nn.LSTMCell(p.input_size, p.hidden_size)\n TestLSTMCell.set_weights(ref_rnn, ref_data)\n test_rnn = LSTMCellNNCF(p.input_size, p.hidden_size)\n TestLSTMCell.set_weights(test_rnn, test_data)\n\n for i in range(p.seq_length):\n ref_result = ref_rnn(ref_data.x[i], (ref_data.h0[0], ref_data.c0[0]))\n test_result = test_rnn(test_data.x[i], (test_data.h0[0], test_data.c0[0]))\n ref_result[0].sum().backward()\n test_result[0].sum().backward()\n ref_grads = get_grads([ref_data.h0[0], ref_data.c0[0]])\n ref_grads += get_grads([ref_rnn.weight_ih, ref_rnn.weight_hh, ref_rnn.bias_ih, ref_rnn.bias_hh])\n test_grads = get_grads([ref_data.h0[0], ref_data.c0[0]])\n test_grads += get_grads([test_rnn.weight_ih, test_rnn.weight_hh, test_rnn.bias_ih, test_rnn.bias_hh])\n for (ref, test) in list(zip(test_grads, ref_grads)):\n torch.testing.assert_allclose(test, ref)\n\n\ndef test_export_lstm_cell(tmp_path):\n config = get_empty_config(model_size=1, input_sample_size=(1, 1))\n config['compression'] = {'algorithm': 'quantization'}\n\n model, algo = create_compressed_model_and_algo_for_test(LSTMCellNNCF(1, 1), config)\n\n test_path = str(tmp_path.joinpath('test.onnx'))\n algo.export_model(test_path)\n assert os.path.exists(test_path)\n\n onnx_num = 0\n model = onnx.load(test_path)\n # pylint: disable=no-member\n for node in model.graph.node:\n if node.op_type == 'FakeQuantize':\n onnx_num += 1\n assert onnx_num == 12\n\n\[email protected]('sizes',\n [LSTMTestSizes(512, 324, 128, 50),\n LSTMTestSizes(3, 3, 3, 3),\n LSTMTestSizes(1, 1, 1, 1)], ids=lambda val: '[{}]'.format('-'.join([str(v) for v in val])))\[email protected]('bidirectional', (True, False), ids=('bi', 'uni'))\[email protected](\"bias\", [True, False], ids=['bias', 'no_bias'])\[email protected]('num_layers', [1, 2], ids=['single_layer', 'stacked'])\[email protected]('batch_first', [True, False], ids=['batch_first', 'seq_first'])\[email protected](('variable_length', 'sorted_'),\n ([True, True],\n [True, False],\n [False, False]), ids=['packed_sorted', 'packed_unsorted', 'not_packed'])\[email protected]('is_cuda', [True, False], ids=['cuda', 'cpu'])\[email protected]('empty_initial', [True, False], ids=['no_initial', 'with_initial'])\n# TODO: dropout gives different result. Looks like different random seed on CPU\n# @pytest.mark.parametrize('dropout', [0, 0.9], ids=['no_dropout', 'with_dropout'])\[email protected]('dropout', [0], ids=['no_dropout'])\nclass TestLSTM:\n def test_forward_lstm(self, sizes, bidirectional, num_layers, bias, batch_first, variable_length, sorted_, is_cuda,\n empty_initial, dropout, _seed):\n num_directions = 2 if bidirectional else 1\n p = sizes\n\n ref_data = TestLSTMCell.generate_lstm_data(p, num_layers, num_directions, variable_length, sorted_, batch_first,\n is_cuda, bias, empty_initial)\n\n ref_rnn = nn.LSTM(input_size=p.input_size, hidden_size=p.hidden_size, num_layers=num_layers,\n bidirectional=bidirectional, batch_first=batch_first, bias=bias, dropout=dropout)\n self.set_ref_lstm_weights(ref_data, ref_rnn, num_layers, num_directions, bias)\n ref_hidden = None if empty_initial else self.get_ref_lstm_hidden(ref_data)\n\n test_data = LSTMTestData(*clone_test_data(ref_data))\n\n class ModelWrapper(nn.Module):\n def __init__(self, lstm):\n super().__init__()\n self.lstm = lstm\n\n def forward(self, *input_):\n return self.lstm(*input_)\n\n wrapped_ref_rnn = ModelWrapper(ref_rnn)\n wrapped_test_rnn = replace_lstm(copy.deepcopy(wrapped_ref_rnn))\n test_rnn = wrapped_test_rnn.lstm\n test_hidden = None if empty_initial else self.get_test_lstm_hidden(test_data)\n\n if is_cuda:\n ref_rnn.cuda()\n test_rnn.cuda()\n ref_output, (ref_hn, ref_cn) = ref_rnn(ref_data.x, ref_hidden)\n test_output, (test_hn, test_cn) = test_rnn(test_data.x, test_hidden)\n\n torch.testing.assert_allclose(test_hn[0], ref_hn[0], rtol=1e-3, atol=1e-4)\n torch.testing.assert_allclose(test_cn[0], ref_cn[0], rtol=1e-3, atol=1e-4)\n if variable_length:\n torch.testing.assert_allclose(test_output.batch_sizes, ref_output.batch_sizes)\n torch.testing.assert_allclose(test_output.data, ref_output.data, rtol=1e-2, atol=1e-3)\n if not sorted_:\n torch.testing.assert_allclose(test_output.sorted_indices, ref_output.sorted_indices)\n torch.testing.assert_allclose(test_output.unsorted_indices, ref_output.unsorted_indices)\n else:\n torch.testing.assert_allclose(test_output, ref_output, rtol=1e-2, atol=1e-3)\n\n def test_backward_lstm(self, sizes, bidirectional, num_layers, bias, batch_first, variable_length, sorted_, is_cuda,\n empty_initial, dropout, _seed):\n\n num_directions = 2 if bidirectional else 1\n\n p = sizes\n\n ref_data = TestLSTMCell.generate_lstm_data(p, num_layers, num_directions, variable_length, sorted_, batch_first,\n is_cuda, bias, empty_initial, True)\n\n ref_rnn = nn.LSTM(input_size=p.input_size, hidden_size=p.hidden_size, num_layers=num_layers,\n bidirectional=bidirectional, batch_first=batch_first, bias=bias, dropout=dropout)\n self.set_ref_lstm_weights(ref_data, ref_rnn, num_layers, num_directions, bias)\n ref_hidden = None if empty_initial else self.get_ref_lstm_hidden(ref_data)\n\n test_data = LSTMTestData(*clone_test_data(ref_data))\n test_rnn = replace_lstm(copy.deepcopy(ref_rnn))\n test_hidden = None if empty_initial else self.get_test_lstm_hidden(test_data)\n\n if is_cuda:\n ref_rnn.cuda()\n test_rnn.cuda()\n\n ref_output, _ = ref_rnn(ref_data.x, ref_hidden)\n test_output, _ = test_rnn(test_data.x, test_hidden)\n\n ref_output[0].sum().backward()\n test_output[0].sum().backward()\n\n ref_grads = get_grads(self.flatten_nested_lists(ref_rnn.all_weights))\n test_grads = get_grads(self.flatten_nested_lists(test_rnn.all_weights))\n if not empty_initial:\n # TODO: compare gradient of all hidden\n ref_grads += get_grads([ref_data.h0[0], ref_data.c0[0]])\n test_grads += get_grads([test_hidden[0][0], test_hidden[1][0]])\n for (ref, test) in list(zip(test_grads, ref_grads)):\n torch.testing.assert_allclose(test, ref, rtol=1e-1, atol=1e-1)\n\n @classmethod\n def flatten_nested_lists(cls, nested_list):\n # type: (List) -> List[torch.Tensor]\n return [tensor for tensor_tuple in nested_list for tensor in tensor_tuple]\n\n @classmethod\n def get_test_lstm_hidden(cls, data):\n # type: (LSTMTestData) -> List[Tuple[torch.Tensor, ...]]\n result = []\n hidden_names = ['h0', 'c0']\n for name in hidden_names:\n hidden_list = getattr(data, name)\n element = ()\n num_hidden = len(hidden_list)\n for i in range(num_hidden):\n element += (hidden_list[i],)\n result.append(element)\n return result\n\n @classmethod\n def get_ref_lstm_hidden(cls, data):\n # type: (LSTMTestData) -> Tuple[torch.Tensor, torch.Tensor]\n hidden = cls.get_test_lstm_hidden(data)\n hidden_states = [torch.unsqueeze(tensor, dim=0) for tensor in hidden[0]]\n cell_states = [torch.unsqueeze(tensor, dim=0) for tensor in hidden[1]]\n return (\n torch.cat(hidden_states, dim=0),\n torch.cat(cell_states, dim=0)\n )\n\n @classmethod\n def set_ref_lstm_weights(cls, data, nn_lstm, num_layers, num_directions, bias):\n # type: (LSTMTestData, nn.LSTM, int, int, bool) -> None\n for l in range(num_layers):\n for d in range(num_directions):\n i = l * num_directions + d\n for name in cls.get_param_names(bias):\n suffix = '_reverse' if d == 1 else ''\n param = getattr(data, name)\n param_name = name + '_l{}{}'.format(l, suffix)\n getattr(nn_lstm, param_name).data.copy_(param[i].data)\n\n @classmethod\n def get_param_names(cls, bias):\n # type: (bool) -> List[str]\n suffixes = ['ih', 'hh']\n names = ['weight_' + suffix for suffix in suffixes]\n if bias:\n names += ['bias_' + suffix for suffix in suffixes]\n return names\n\n\ndef test_export_stacked_bi_lstm(tmp_path):\n p = LSTMTestSizes(3, 3, 3, 3)\n config = get_empty_config(input_sample_size=(1, p.hidden_size, p.input_size))\n config['compression'] = {'algorithm': 'quantization'}\n\n # TODO: batch_first=True fails with building graph: ambiguous call to mul or sigmoid\n test_rnn = NNCF_RNN('LSTM', input_size=p.input_size, hidden_size=p.hidden_size, num_layers=2, bidirectional=True,\n batch_first=False)\n model, algo = create_compressed_model_and_algo_for_test(test_rnn, config)\n\n test_path = str(tmp_path.joinpath('test.onnx'))\n algo.export_model(test_path)\n assert os.path.exists(test_path)\n\n onnx_num = 0\n model = onnx.load(test_path)\n # pylint: disable=no-member\n for node in model.graph.node:\n if node.op_type == 'FakeQuantize':\n onnx_num += 1\n assert onnx_num == 50\n\n\nclass TestNumberOfNodes:\n logging.basicConfig(level=logging.INFO, stream=sys.stdout)\n\n def test_number_of_calling_fq_for_lstm(self):\n p = LSTMTestSizes(1, 1, 1, 5)\n num_layers = 2\n bidirectional = True\n num_directions = 2 if bidirectional else 1\n bias = True\n batch_first = False\n config = get_empty_config(input_sample_size=(p.seq_length, p.batch, p.input_size))\n config['compression'] = {'algorithm': 'quantization', 'quantize_inputs': True}\n\n test_data = TestLSTMCell.generate_lstm_data(p, num_layers, num_directions, bias=bias, batch_first=batch_first)\n\n test_rnn = NNCF_RNN('LSTM', input_size=p.input_size, hidden_size=p.hidden_size, num_layers=num_layers,\n bidirectional=bidirectional, bias=bias, batch_first=batch_first)\n TestLSTM.set_ref_lstm_weights(test_data, test_rnn, num_layers, num_directions, bias)\n test_hidden = TestLSTM.get_test_lstm_hidden(test_data)\n\n model, algo = create_compressed_model_and_algo_for_test(test_rnn, config)\n\n class Counter:\n def __init__(self):\n self.count = 0\n\n def next(self):\n self.count += 1\n\n def hook(model, input_, counter):\n counter.next()\n\n counters = {}\n for name, quantizer in algo.all_quantizations.items():\n counter = Counter()\n counters[name] = counter\n quantizer.register_forward_pre_hook(partial(hook, counter=counter))\n _ = model(test_data.x, test_hidden)\n assert model.get_graph().get_nodes_count() == 107 # NB: may always fail in debug due to superfluous 'cat' nodes\n assert len(counters) == 50\n for counter in counters.values():\n assert counter.count == p.seq_length\n\n def test_number_of_calling_fq_for_gnmt(self):\n torch.cuda.set_device(0)\n device = torch.device('cuda')\n batch_first = False\n vocab_size = 32000\n model_config = {'hidden_size': 100,\n 'vocab_size': vocab_size,\n 'num_layers': 4,\n 'dropout': 0.2,\n 'batch_first': batch_first,\n 'share_embedding': True,\n }\n batch_size = 128\n sequence_size = 50\n input_sample_size = (batch_size, sequence_size) if batch_first else (sequence_size, batch_size)\n config = get_empty_config(input_sample_size=input_sample_size)\n config['compression'] = \\\n {'algorithm': 'quantization',\n 'quantize_inputs': True,\n 'quantizable_subgraph_patterns': [[\"linear\", \"__add__\"],\n [\"sigmoid\", \"__mul__\", \"__add__\"],\n [\"__add__\", \"tanh\", \"__mul__\"],\n [\"sigmoid\", \"__mul__\"]],\n 'disable_function_quantization_hooks': True}\n config['scopes_without_shape_matching'] = \\\n ['GNMT/ResidualRecurrentDecoder[decoder]/RecurrentAttention[att_rnn]/BahdanauAttention[attn]', ]\n\n model = GNMT(**model_config)\n model = replace_lstm(model)\n model.to(device)\n\n def dummy_forward_fn(model, seq_len=sequence_size):\n def gen_packed_sequence():\n seq_list = []\n seq_lens = torch.LongTensor(batch_size).random_(1, seq_len + 1)\n seq_lens = torch.sort(seq_lens, descending=True).values\n for seq_size in seq_lens:\n seq_list.append(torch.LongTensor(seq_size.item()).random_(1, vocab_size).to(device))\n padded_seq_batch = torch.nn.utils.rnn.pad_sequence(seq_list, batch_first=batch_first)\n return padded_seq_batch, seq_lens\n\n x_data, seq_lens = gen_packed_sequence()\n input_encoder = x_data\n input_enc_len = seq_lens.to(device)\n input_decoder = gen_packed_sequence()[0]\n model(input_encoder, input_enc_len, input_decoder)\n\n algo, model = create_compressed_model(model, config, dummy_forward_fn, dump_graphs=False)\n model.to(device)\n\n class Counter:\n def __init__(self):\n self.count = 0\n\n def next(self):\n self.count += 1\n\n def hook(model, input_, counter):\n counter.next()\n\n counters = {}\n for name, quantizer in algo.all_quantizations.items():\n counter = Counter()\n counters[str(name)] = counter\n quantizer.register_forward_pre_hook(partial(hook, counter=counter))\n dummy_forward_fn(model)\n assert model.get_graph().get_nodes_count() == 230 # NB: may always fail in debug due to superfluous 'cat' nodes\n assert len(counters) == 55\n for name, counter in counters.items():\n if 'cell' in name or \"LSTMCellForwardNNCF\" in name:\n assert counter.count == sequence_size, name\n else:\n assert counter.count == 1, name\n new_seq_len = int(sequence_size / 2)\n dummy_forward_fn(model, new_seq_len)\n assert model.get_graph().get_nodes_count() == 230 # NB: may always fail in debug due to superfluous 'cat' nodes\n assert len(counters) == 55\n for name, counter in counters.items():\n if 'cell' in name or \"LSTMCellForwardNNCF\" in name:\n assert counter.count == sequence_size + new_seq_len, name\n else:\n assert counter.count == 2, name\n\n def test_number_of_nodes_for_module_in_loop(self):\n num_iter = 5\n\n class LoopModule(nn.Module):\n @ITERATION_MODULES.register('Inner')\n class Inner(nn.Module):\n def __init__(self):\n super().__init__()\n self.operator1 = torch.sigmoid\n self.operator2 = torch.tanh\n\n def forward(self, x):\n s = self.operator1(x)\n t = self.operator2(x)\n result = t + s\n return result\n\n @staticmethod\n def nodes_number():\n return 3\n\n def __init__(self):\n super().__init__()\n self.inner = self.Inner()\n\n def forward(self, x):\n for _ in range(num_iter):\n x = self.inner(x)\n return x\n\n def nodes_number(self):\n return self.inner.nodes_number()\n\n test_module = LoopModule()\n context = TracingContext()\n with context as ctx:\n _ = test_module(torch.zeros(1))\n assert ctx.graph.get_nodes_count() == test_module.nodes_number()\n\n def test_number_of_nodes_for_module_in_loop__not_input_node(self):\n num_iter = 5\n\n class LoopModule(nn.Module):\n class Inner(nn.Module):\n def forward(self, x):\n s = F.sigmoid(x)\n t = F.tanh(x)\n result = F.sigmoid(x) * t + F.tanh(x) * s\n return result\n\n @staticmethod\n def nodes_number():\n return 7\n\n def __init__(self):\n super().__init__()\n self.inner = self.Inner()\n\n def forward(self, x):\n for _ in range(num_iter):\n x = self.inner(F.relu(x))\n return x\n\n def nodes_number(self):\n return self.inner.nodes_number() + num_iter\n\n test_module = LoopModule()\n context = TracingContext()\n with context as ctx:\n _ = test_module(torch.zeros(1))\n assert ctx.graph.get_nodes_count() == test_module.nodes_number()\n\n def test_number_of_nodes_for_module_with_nested_loops(self):\n num_iter = 5\n\n class TestIterModule(nn.Module):\n @ITERATION_MODULES.register()\n class TestIterModule_ResetPoint(nn.Module):\n def __init__(self, loop_module):\n super().__init__()\n self.loop_module = loop_module\n\n def forward(self, x):\n return self.loop_module(F.relu(x))\n\n def __init__(self):\n super().__init__()\n self.loop_module = self.LoopModule2()\n self.reset_point = self.TestIterModule_ResetPoint(self.loop_module)\n\n def forward(self, x):\n for _ in range(num_iter):\n x = self.reset_point(x)\n return x\n\n class LoopModule2(nn.Module):\n\n @ITERATION_MODULES.register()\n class LoopModule2_ResetPoint(nn.Module):\n def __init__(self, inner):\n super().__init__()\n self.inner = inner\n\n def forward(self, x):\n return self.inner(F.relu(x))\n\n def __init__(self):\n super().__init__()\n self.inner = self.Inner()\n self.reset_helper = self.LoopModule2_ResetPoint(self.inner)\n\n def forward(self, x):\n for _ in range(num_iter):\n self.reset_helper(x)\n return x\n\n class Inner(nn.Module):\n def forward(self, x):\n s = F.sigmoid(x)\n t = F.tanh(x)\n result = t + s\n return result\n\n test_module = TestIterModule()\n context = TracingContext()\n with context as ctx:\n _ = test_module(torch.zeros(1))\n assert ctx.graph.get_nodes_count() == num_iter\n\n def test_number_of_nodes_for_repeated_module(self):\n\n class LoopModule(nn.Module):\n def __init__(self):\n super().__init__()\n self.operator = F.relu\n self.layers = nn.ModuleList([\n nn.Conv2d(1, 1, 1),\n nn.Conv2d(1, 1, 1)\n ])\n\n def forward(self, x):\n for layer in self.layers:\n x = F.relu(layer(x))\n return x\n\n test_module = LoopModule()\n context = TracingContext()\n with context as ctx:\n x = test_module(torch.zeros(1, 1, 1, 1))\n assert ctx.graph.get_nodes_count() == 4 # NB: may always fail in debug due to superfluous 'cat' nodes\n _ = test_module(x)\n assert ctx.graph.get_nodes_count() == 8 # NB: may always fail in debug due to superfluous 'cat' nodes\n",
"#!/usr/bin/env python3\n#\n# Copyright (C) 2019 Intel Corporation\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,\n# software 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\n# and limitations under the License.\n\n# pylint: disable=line-too-long\n\nimport os\nimport matplotlib; matplotlib.use('Agg') # pylint: disable=multiple-statements\nfrom ssd_detector.readers.object_detector_json import ObjectDetectorJson\n\nCURRENT_DIR = os.path.dirname(os.path.realpath(__file__))\nROOT_DIR = os.path.normpath(os.path.join(CURRENT_DIR, \"../../..\"))\n\n# See more details about parameters in TensorFlow documentation tf.estimator\nclass train:\n annotation_path = os.path.join(ROOT_DIR, \"./data/vlp_test/annotations_train.json\") # Path to the annotation file\n cache_type = \"ENCODED\" # Type of data to save in memory, possible options: 'FULL', 'ENCODED', 'NONE'\n\n batch_size = 32 # Number of images in the batch\n steps = 65000 # Number of steps for which to train model\n max_steps = None # Number of total steps for which to train model\n save_checkpoints_steps = 1000 # Number of training steps when checkpoint should be saved\n keep_checkpoint_every_n_hours = 6 # Checkpoint should be saved forever after every n hours\n save_summary_steps = 100 # Number of steps when the summary information should be saved\n random_seed = 666 # Random seed\n\n fill_with_current_image_mean = True # Parameter of data transformer\n\n class execution:\n CUDA_VISIBLE_DEVICES = \"0\" # Environment variable to control CUDA device used for training\n per_process_gpu_memory_fraction = 0.8 # Fix extra memory allocation issue\n allow_growth = True # Option which attempts to allocate only as much GPU memory based on runtime allocations\n\n intra_op_parallelism_threads = 2\n inter_op_parallelism_threads = 8\n transformer_parallel_calls = 4 # Number of parallel threads in data transformer/augmentation\n transformer_prefetch_size = 8 # Number of batches to prefetch\n\n\nclass eval:\n annotation_path = {\n \"train\": os.path.join(ROOT_DIR, \"./data/vlp_test/annotations_train.json\"),\n \"test\": os.path.join(ROOT_DIR, \"./data/vlp_test/annotations_test.json\")\n } # Dictionary with paths to annotations and its short names which will be displayed in the TensorBoard\n datasets = [\"train\", \"test\"] # List of names from annotation_path dictionary on which evaluation will be launched\n vis_num = 2 # Select random images for visualization in the TensorBoard\n save_images_step = 2 # Save images every 2-th evaluation\n batch_size = 2 # Number of images in the batch\n\n class execution:\n CUDA_VISIBLE_DEVICES = \"0\" # Environment variable to control CUDA device used for evaluation\n per_process_gpu_memory_fraction = 0.5 # Fix extra memory allocation issue\n allow_growth = True # Option which attempts to allocate only as much GPU memory based on runtime allocations\n\n intra_op_parallelism_threads = 1\n inter_op_parallelism_threads = 1\n transformer_parallel_calls = 1 # Number of parallel threads in data transformer/augmentation\n transformer_prefetch_size = 1 # Number of batches to prefetch\n\n\nclass infer:\n out_subdir = \"predictions\" # Name of folder in model directory where output json files with detections will be saved\n batch_size = 32 # Number of images in the batch\n\n class execution:\n CUDA_VISIBLE_DEVICES = \"0\" # Environment variable to control cuda device used for training\n per_process_gpu_memory_fraction = 0.5 # Fix extra memory allocation issue\n allow_growth = True # Option which attempts to allocate only as much GPU memory based on runtime allocations\n\n intra_op_parallelism_threads = 2\n inter_op_parallelism_threads = 8\n transformer_parallel_calls = 4 # Number of parallel threads in data transformer/augmentation\n transformer_prefetch_size = 8 # Number of batches to prefetch\n\n\ninput_shape = (256, 256, 3) # Input shape of the model (width, height, channels)\nclasses = ObjectDetectorJson.get_classes_from_coco_annotation(os.path.join(CURRENT_DIR, train.annotation_path))\nMODEL_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)),\n 'model') # Path to the folder where all training and evaluation artifacts will be located\nif not os.path.exists(MODEL_DIR):\n os.makedirs(MODEL_DIR)\n\n\ndef learning_rate_schedule(): # Function which controls learning rate during training\n import tensorflow as tf\n step = tf.train.get_or_create_global_step()\n lr = tf.case([(tf.less(step, 1000), lambda: tf.constant(0.0004)),\n (tf.less(step, 10000), lambda: tf.constant(0.01)),\n (tf.less(step, 40000), lambda: tf.constant(0.005)),\n (tf.less(step, 55000), lambda: tf.constant(0.0005)),\n (tf.less(step, 65000), lambda: tf.constant(0.00005))])\n return lr\n\n\ndef optimizer(learning_rate):\n import tensorflow as tf\n return tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.95)\n\n\ndetector_params = {\n \"num_classes\": len(classes), # Number of classes to detect\n \"priors_rule\": \"custom\", # Prior boxes rule for SSD, possible options: 'caffe', 'object_detection_api', 'custom'\n \"priors\": [\n [(0.068, 0.03), (0.052, 0.097)],\n [(0.18, 0.087), (0.11, 0.33), (0.43, 0.1)],\n [(0.26, 0.27), (0.34, 0.4), (0.2, 0.55)],\n [(0.37, 0.52)],\n [(0.48, 0.45)],\n [(0.63, 0.64), (0.77, 0.77), (0.95, 0.95)]\n ],\n \"mobilenet_version\": \"v2\", # Version of mobilenet backbone, possible options: 'v1', 'v2'\n \"initial_weights_path\": \"\", # Path to initial weights\n \"depth_multiplier\": 0.35, # MobileNet channels multiplier\n \"weight_regularization\": 1e-3, # L2 weight regularization\n \"learning_rate\": learning_rate_schedule, # Learning rate\n \"optimizer\": optimizer, # Optimizer\n \"collect_priors_summary\": False, # Option to collect priors summary for further analysis\n}\n",
"\"\"\"\n Copyright (c) 2019-2020 Intel Corporation\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 http://www.apache.org/licenses/LICENSE-2.0\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\n\nfrom collections import OrderedDict\nfrom enum import Enum\nfrom typing import List, Callable, Tuple, Dict, Optional\n\nimport functools\nimport networkx as nx\nimport torch\nfrom copy import deepcopy\nfrom torch import nn\n\nfrom nncf.debug import CombinedDebugInterface, debuggable_forward, is_debug\nfrom nncf.dynamic_graph.context import TracingContext\nfrom nncf.dynamic_graph.graph import NNCFGraph, InputAgnosticOperationExecutionContext, OperationExecutionContext\nfrom nncf.dynamic_graph.graph import ShapeIgnoringTensorMetaComparator\nfrom nncf.dynamic_graph.graph_builder import GraphBuilder, PostGraphBuildActing, create_dummy_forward_fn, ModelInputInfo\nfrom nncf.dynamic_graph.graph_matching import NodeExpression\nfrom nncf.dynamic_graph.patch_pytorch import ignore_scope, nncf_model_input, MODEL_INPUT_OP_NAME\nfrom nncf.dynamic_graph.operator_metatypes import OPERATOR_METATYPES\nfrom nncf.dynamic_graph.transform_graph import replace_modules_by_nncf_modules\nfrom nncf.hw_config import HWConfig\nfrom nncf.layers import NNCF_MODULES\nfrom nncf.quantization.layers import QUANTIZATION_MODULES\nfrom nncf.utils import get_all_modules_by_type, get_state_dict_names_with_modules\nfrom nncf.nncf_logger import logger as nncf_logger\n\nMODEL_WRAPPED_BY_NNCF_ATTR_NAME = 'nncf_module'\n\n\nclass CompressionModuleType(Enum):\n FUNCTION_QUANTIZER = 0\n ACTIVATION_QUANTIZER = 1\n\n\[email protected]_ordering\nclass OperationPriority(Enum):\n DEFAULT_PRIORITY = 0\n SPARSIFICATION_PRIORITY = 2\n QUANTIZATION_PRIORITY = 11\n PRUNING_PRIORITY = 1\n\n def __lt__(self, other):\n # pylint: disable=comparison-with-callable\n return self.value < other.value\n\n\nclass InsertionType(Enum):\n OPERATOR_PRE_HOOK = 0\n OPERATOR_POST_HOOK = 1\n NNCF_MODULE_PRE_OP = 2\n NNCF_MODULE_POST_OP = 3\n\n def __eq__(self, other):\n # pylint: disable=comparison-with-callable\n if isinstance(other, InsertionType):\n return self.value == other.value\n return self.value == other\n\n\nclass InsertionInfo:\n def __init__(self, op_exec_context: OperationExecutionContext,\n is_input=False,\n is_output=False,\n shape_to_operate_on=None):\n self.op_exec_context = op_exec_context # type: OperationExecutionContext\n self.is_input = is_input\n self.is_output = is_output\n self.shape_to_operate_on = shape_to_operate_on\n\n def __eq__(self, other: 'InsertionInfo'):\n return self.op_exec_context == other.op_exec_context\n\n def __hash__(self):\n return self.op_exec_context.__hash__()\n\n\nclass InsertionPoint:\n def __init__(self, ia_op_exec_context: InputAgnosticOperationExecutionContext,\n insertion_type: InsertionType):\n self.ia_op_exec_context = ia_op_exec_context\n self.insertion_type = insertion_type\n\n def __eq__(self, other: 'InsertionPoint'):\n return self.insertion_type == other.insertion_type and self.ia_op_exec_context == other.ia_op_exec_context\n\n def __str__(self):\n return str(self.insertion_type) + \" \" + str(self.ia_op_exec_context)\n\n def __hash__(self):\n return hash(str(self))\n\n\nclass InsertionCommand:\n def __init__(self, point: InsertionPoint, fn: Callable,\n priority: OperationPriority = OperationPriority.DEFAULT_PRIORITY):\n self.insertion_point = point # type: InsertionPoint\n self.fn = fn # type: Callable\n self.priority = priority # type: OperationPriority\n\n\nclass LoadStateListener:\n \"\"\"\n Resets the initialization flags (`initialized`) for all quantization modules on `load_state_dict` call.\n These flags are used to update not loaded params (from checkpoint or model's state)\n on initialization stage of algorithm.\n Flags reset is required on each call of `load_state_dict`, because internal method (`build_graph`)\n restores model state by calling this method.\n \"\"\"\n\n def __init__(self, model, all_quantizations):\n for prefix, module in all_quantizations.items():\n module.state_dict_name = prefix\n # pylint: disable=protected-access\n self.hook = model._register_load_state_dict_pre_hook(\n functools.partial(self.hook_fn, quantize_modules=all_quantizations.values()))\n\n def hook_fn(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs,\n quantize_modules):\n for module in quantize_modules:\n module.initialized = False\n\n def close(self):\n self.hook.remove()\n\n\nclass InsertionPointGraphNodeType(Enum):\n INSERTION_POINT = 0\n OPERATOR = 1\n\n\nclass InsertionPointGraph(nx.DiGraph):\n \"\"\"\n This graph is built from the NNCFGraph representation of the model control flow graph and adds ephemeral\n \"insertion point nodes\" into the NNCF model graph representation corresponding to operator pre- and\n post-hooks. Module pre-op and post-op insertion points are currently not reflected here, but they are\n probably not required for quantizing activations, for which the quantizer propagation makes sense.\n This \"insertion point graph\" representation is useful for quantizer propagation and for referencing\n the compression algorithm hooks to the model operations to which they are applied to.\n \"\"\"\n NODE_TYPE_NODE_ATTR = \"node_type\"\n INSERTION_POINT_DATA_NODE_ATTR = \"insertion_point_data\"\n IS_IN_NNCF_MODULE_NODE_ATTR = \"is_in_nncf_module\"\n REGULAR_NODE_REF_NODE_ATTR = \"regular_node_ref\"\n ASSOCIATED_IP_NODE_KEYS_NODE_ATTR = \"associated_ip_node_keys\"\n OPERATOR_METATYPE_NODE_ATTR = \"op_meta\"\n\n PRE_HOOK_ID_PREFIX = \"PRE HOOK \" # NB: Do not use colon (':') in node keys! Causes trouble for .dot file export.\n POST_HOOK_ID_PREFIX = \"POST HOOK \"\n\n def __init__(self, model_nx_graph: nx.DiGraph):\n super().__init__()\n self._base_nx_graph = deepcopy(model_nx_graph)\n\n for node_key, node in self._base_nx_graph.nodes.items():\n attrs = {InsertionPointGraph.REGULAR_NODE_REF_NODE_ATTR: node,\n InsertionPointGraph.NODE_TYPE_NODE_ATTR: InsertionPointGraphNodeType.OPERATOR,\n InsertionPointGraph.ASSOCIATED_IP_NODE_KEYS_NODE_ATTR: set(),\n InsertionPointGraph.OPERATOR_METATYPE_NODE_ATTR: None}\n self.add_node(node_key, **attrs)\n for from_node, to_node in self._base_nx_graph.edges:\n self.add_edge(from_node, to_node)\n\n # TODO: Add insertion points for module pre- and post-ops.\n # Should roughly look so: first, determine subsets of nodes belonging to each\n # separate NNCF module (via scope analysis), then for each subset find input/output\n # edges using a corresponding NNCFGraph function; add a pre-op insertion point node as the\n # sink for input edges and connect it to input edge destinations, then add a post-op\n # insertion point as the source of output edges and connect it to output edge origins.\n\n node_keys_working_set = [deepcopy(node_key) for node_key in self.nodes.keys()]\n for operator_node_key in node_keys_working_set:\n original_node = self.nodes[operator_node_key][InsertionPointGraph.REGULAR_NODE_REF_NODE_ATTR]\n ia_op_exec_context = original_node[NNCFGraph.OP_EXEC_CONTEXT_NODE_ATTR].input_agnostic\n\n # Pre-hook insertion point nodes\n pre_hook_insertion_point = InsertionPoint(ia_op_exec_context,\n InsertionType.OPERATOR_PRE_HOOK)\n attrs = {\n InsertionPointGraph.NODE_TYPE_NODE_ATTR: InsertionPointGraphNodeType.INSERTION_POINT,\n InsertionPointGraph.INSERTION_POINT_DATA_NODE_ATTR: pre_hook_insertion_point,\n }\n ip_node_key = self.get_pre_hook_node_key(str(operator_node_key))\n self.add_node(ip_node_key, **attrs)\n in_edges = list(self.in_edges(operator_node_key))\n for from_node_key, to_node_key in in_edges:\n self.remove_edge(from_node_key, to_node_key)\n self.add_edge(from_node_key, ip_node_key)\n self.add_edge(ip_node_key, operator_node_key)\n operator_node = self.nodes[operator_node_key]\n operator_node[InsertionPointGraph.ASSOCIATED_IP_NODE_KEYS_NODE_ATTR].add(ip_node_key)\n\n # Post-hook insertion point nodes\n post_hook_insertion_point = InsertionPoint(ia_op_exec_context,\n InsertionType.OPERATOR_POST_HOOK)\n attrs = {\n InsertionPointGraph.NODE_TYPE_NODE_ATTR: InsertionPointGraphNodeType.INSERTION_POINT,\n InsertionPointGraph.INSERTION_POINT_DATA_NODE_ATTR: post_hook_insertion_point\n }\n ip_node_key = self.get_post_hook_node_key(str(operator_node_key))\n self.add_node(ip_node_key, **attrs)\n out_edges = list(self.out_edges(operator_node_key))\n for from_node_key, to_node_key in out_edges:\n self.remove_edge(from_node_key, to_node_key)\n self.add_edge(ip_node_key, to_node_key)\n # TODO: introduce separate insertion points for operator outputs if\n # the outputs are semantically different\n self.add_edge(operator_node_key, ip_node_key)\n operator_node = self.nodes[operator_node_key]\n operator_node[InsertionPointGraph.ASSOCIATED_IP_NODE_KEYS_NODE_ATTR].add(ip_node_key)\n\n def get_ip_graph_with_merged_hw_optimized_operations(self,\n hw_config: Optional[HWConfig] = None) -> 'InsertionPointGraph':\n merged_ip_graph = deepcopy(self)\n pattern = self._get_mergeable_operator_patterns(hw_config)\n from nncf.dynamic_graph.graph_matching import search_all\n matches = search_all(self._base_nx_graph, pattern)\n for match in matches:\n if len(match) == 1:\n continue\n\n input_node_key = match[0]\n output_node_key = match[-1]\n in_edges = list(self.in_edges(input_node_key))\n out_edges = list(self.out_edges(output_node_key))\n\n assert len(in_edges) <= 1 # TODO: change to == 1 when input nodes are handled correctly\n\n if in_edges:\n in_edge_key = in_edges[0]\n in_edge_copy = deepcopy(self.edges[in_edge_key])\n out_edge_copies_dict = {}\n for out_edge_key in out_edges:\n out_edge_copies_dict[out_edge_key] = deepcopy(self.edges[out_edge_key])\n\n conserved_edges_list = out_edges\n if in_edges:\n conserved_edges_list.append(in_edge_key)\n\n merged_node_attrs = deepcopy(self.nodes[input_node_key])\n merged_node_attrs[InsertionPointGraph.ASSOCIATED_IP_NODE_KEYS_NODE_ATTR] = set()\n merged_node_key = \"\"\n for node_key in match:\n ip_node_keys = self.nodes[node_key][InsertionPointGraph.ASSOCIATED_IP_NODE_KEYS_NODE_ATTR]\n for ip_node_key in ip_node_keys:\n should_keep_ip_node = False\n for edge_key in conserved_edges_list:\n if ip_node_key in edge_key:\n should_keep_ip_node = True\n break\n if should_keep_ip_node:\n merged_node_attrs[InsertionPointGraph.ASSOCIATED_IP_NODE_KEYS_NODE_ATTR].add(ip_node_key)\n else:\n merged_ip_graph.remove_node(ip_node_key)\n merged_ip_graph.remove_node(node_key)\n merged_node_key += node_key + '\\n'\n\n merged_ip_graph.add_node(merged_node_key, **merged_node_attrs)\n if in_edges:\n merged_ip_graph.add_edge(in_edge_key[0], merged_node_key, **in_edge_copy)\n for out_edge_key, out_edge_attrs in out_edge_copies_dict.items():\n merged_ip_graph.add_edge(merged_node_key, out_edge_key[1], **out_edge_attrs)\n\n return merged_ip_graph\n\n @staticmethod\n def get_pre_hook_node_key(node_key: str):\n return InsertionPointGraph.PRE_HOOK_ID_PREFIX + node_key\n\n @staticmethod\n def get_post_hook_node_key(node_key: str):\n return InsertionPointGraph.POST_HOOK_ID_PREFIX + node_key\n\n def _get_mergeable_operator_patterns(self, hw_config: Optional[HWConfig] = None) -> NodeExpression:\n \"\"\"Resulting pattern should have single input; the operation with inputs to\n quantize should be the input operation; outputs should only be produced by one output node.\"\"\"\n # TODO: Implement \"repeating expressions\" so that any number of \"mergeable\" operations\n # immediately following a linear/convolutional/matrix op are merged into one block\n import nncf.dynamic_graph.patterns as p\n pattern = p.LINEAR_OPS + p.ANY_BN_RELU_COMBO | p.LINEAR_OPS + p.ELTWISE_UNIFORM_OPS\n return pattern\n\n def get_op_nodes_in_scope(self, scope: 'Scope') -> List:\n matching_ip_graph_op_nodes_list = []\n for node in self.nodes().values():\n if node[InsertionPointGraph.NODE_TYPE_NODE_ATTR] == InsertionPointGraphNodeType.OPERATOR:\n nncf_graph_node_ref = node[InsertionPointGraph.REGULAR_NODE_REF_NODE_ATTR]\n op_exec_context = nncf_graph_node_ref[NNCFGraph.OP_EXEC_CONTEXT_NODE_ATTR]\n op_scope = op_exec_context.input_agnostic.scope_in_model\n if op_scope in scope:\n matching_ip_graph_op_nodes_list.append(node)\n return matching_ip_graph_op_nodes_list\n\n# pylint: disable=too-many-public-methods\n@ignore_scope\nclass NNCFNetwork(nn.Module, PostGraphBuildActing):\n\n def __init__(self, module, input_infos: List[ModelInputInfo] = None,\n dummy_forward_fn=None, scopes_without_shape_matching=None,\n ignored_scopes=None, target_scopes=None):\n super().__init__()\n self.set_nncf_wrapped_model(module)\n self.input_infos = input_infos\n self.ignored_scopes = ignored_scopes\n self.target_scopes = target_scopes\n self._dummy_forward_fn = dummy_forward_fn\n self._nncf_module_scopes = [] # type: List[Scope]\n self.scopes_without_shape_matching = scopes_without_shape_matching\n self.debug_interface = CombinedDebugInterface() if is_debug() else None\n self._extra_module_types = [] # type: List[CompressionModuleType]\n # pylint:disable=line-too-long\n self._insertions_into_original_graph = {} # type: Dict[InsertionPoint, List[Tuple[Callable, OperationPriority]]]\n\n device = next(module.parameters()).device\n\n # all modules should be replaced prior to graph building\n self._replace_modules_by_nncf_modules(device)\n\n _orig_context = TracingContext()\n _orig_graph_build_forward_fn = self._get_dummy_forward_fn_for_graph_building(with_input_tracing=True)\n\n self._graph_builder = GraphBuilder(_orig_graph_build_forward_fn)\n\n _orig_context.add_node_comparators([MODEL_INPUT_OP_NAME], ShapeIgnoringTensorMetaComparator())\n if self.scopes_without_shape_matching:\n _orig_context.add_node_comparators(scopes_without_shape_matching,\n ShapeIgnoringTensorMetaComparator())\n\n self._original_graph = self._graph_builder.build_graph(self.get_nncf_wrapped_model(), _orig_context)\n\n self._compressed_context = TracingContext()\n\n self._dummy_forward_fn = self._get_dummy_forward_fn_for_graph_building(with_input_tracing=False)\n\n self._compressed_context.add_node_comparators([MODEL_INPUT_OP_NAME], ShapeIgnoringTensorMetaComparator())\n if self.scopes_without_shape_matching:\n self._compressed_context.add_node_comparators(scopes_without_shape_matching,\n ShapeIgnoringTensorMetaComparator())\n self._load_listener = None\n\n self._builders = [] # type: List['CompressionAlgorithmBuilder']\n\n @debuggable_forward\n def forward(self, *args, **kwargs):\n with self._compressed_context as ctx: # type: TracingContext\n ctx.base_module_thread_local_replica = self\n arglist = list(args)\n for idx, tensor in enumerate(arglist): # TODO: extend to all tensors in args/kwargs hierarchy\n if isinstance(tensor, torch.Tensor):\n arglist[idx] = nncf_model_input(tensor)\n args = tuple(arglist)\n retval = self.get_nncf_wrapped_model()(*args, **kwargs)\n return retval\n\n def register_algorithm(self, builder: 'CompressionAlgorithmBuilder'):\n \"\"\"Should be called during *builder*'s *apply_to* method, otherwise there will be no corresponding\n controller returned by the network on the *commit_compression_changes* stage\"\"\"\n self._builders.append(builder)\n\n # Cannnot use property syntax here, otherwise the wrapped module will end up\n # being twice in the same checkpoint with different prefixes\n def get_nncf_wrapped_model(self):\n return getattr(self, MODEL_WRAPPED_BY_NNCF_ATTR_NAME)\n\n def set_nncf_wrapped_model(self, value):\n setattr(self, MODEL_WRAPPED_BY_NNCF_ATTR_NAME, value)\n\n def get_modules_in_nncf_modules_by_type(self, types) -> Dict['Scope', nn.Module]:\n nncf_modules = self.get_nncf_modules()\n retval = {}\n for nncf_module_scope, nncf_module in nncf_modules.items():\n nncf_module_scope.pop()\n for relative_scope, target_module in get_all_modules_by_type(nncf_module, types).items():\n retval[nncf_module_scope + relative_scope] = target_module\n return retval\n\n def register_insertion_command(self, command: InsertionCommand):\n point = command.insertion_point\n if point not in self._insertions_into_original_graph:\n self._insertions_into_original_graph[point] = [(command.fn, command.priority)]\n else:\n self._insertions_into_original_graph[point].append((command.fn, command.priority))\n\n def commit_compression_changes(self) -> 'CompressionAlgorithmController':\n for insertion_point, fn_list_with_priority in self._insertions_into_original_graph.items():\n fn_list_with_priority = sorted(fn_list_with_priority, key=lambda x: x[1])\n self._insertions_into_original_graph[insertion_point] = fn_list_with_priority\n self._insert_at_point(insertion_point, [x[0] for x in fn_list_with_priority])\n\n if self.debug_interface is not None:\n self.debug_interface.init_actual(self)\n\n quantization_types = [class_type.__name__ for class_type in QUANTIZATION_MODULES.registry_dict.values()]\n all_quantizations = get_state_dict_names_with_modules(self, quantization_types)\n self._load_listener = LoadStateListener(self, all_quantizations)\n\n if not self._builders:\n from nncf.algo_selector import NoCompressionAlgorithmController\n return NoCompressionAlgorithmController(self)\n\n if len(self._builders) == 1:\n return self._builders[0].build_controller(self)\n\n from nncf.composite_compression import CompositeCompressionAlgorithmController\n composite_controller = CompositeCompressionAlgorithmController(self)\n for algo_builder in self._builders:\n composite_controller.add(algo_builder.build_controller(self))\n return composite_controller\n\n def _insert_at_point(self, point: InsertionPoint, fn_list: List[Callable]):\n if point.insertion_type == InsertionType.OPERATOR_PRE_HOOK:\n self._compressed_context.register_pre_hooks(fn_list, point.ia_op_exec_context)\n elif point.insertion_type == InsertionType.OPERATOR_POST_HOOK:\n self._compressed_context.register_post_hooks(fn_list, point.ia_op_exec_context)\n else:\n norm_target_scope = self._normalize_variable_recurrent_scope(point.ia_op_exec_context.scope_in_model)\n norm_nncf_scopes = [self._normalize_variable_recurrent_scope(x) for x in self._nncf_module_scopes]\n assert norm_target_scope in norm_nncf_scopes # Required for proper Recurrent/VariableRecurrent addressing\n nncf_module = self.get_module_by_scope(point.ia_op_exec_context.scope_in_model)\n if point.insertion_type == InsertionType.NNCF_MODULE_PRE_OP:\n for fn in fn_list:\n nncf_module.register_pre_forward_operation(fn)\n elif point.insertion_type == InsertionType.NNCF_MODULE_POST_OP:\n for fn in fn_list:\n nncf_module.register_post_forward_operation(fn)\n\n def __getattr__(self, name):\n wrapped_module = super().__getattr__(MODEL_WRAPPED_BY_NNCF_ATTR_NAME)\n if hasattr(wrapped_module, name):\n return getattr(wrapped_module, name)\n return super().__getattr__(name)\n\n def get_graph(self) -> NNCFGraph:\n return self._compressed_context.graph\n\n def get_original_graph(self) -> NNCFGraph:\n return self._original_graph\n\n def get_tracing_context(self) -> TracingContext:\n return self._compressed_context\n\n def _get_dummy_forward_fn_for_graph_building(self, with_input_tracing):\n if self._dummy_forward_fn is None:\n return create_dummy_forward_fn(self.input_infos,\n with_input_tracing=with_input_tracing)\n return self._dummy_forward_fn\n\n def _replace_modules_by_nncf_modules(self, device):\n module, self._nncf_module_scopes = replace_modules_by_nncf_modules(self.get_nncf_wrapped_model(),\n ignored_scopes=self.ignored_scopes,\n target_scopes=self.target_scopes)\n self.set_nncf_wrapped_model(module.to(device))\n\n def get_nncf_module_scopes(self) -> List['Scope']:\n return self._nncf_module_scopes\n\n def get_nncf_modules(self) -> Dict['Scope', torch.nn.Module]:\n return get_all_modules_by_type(self.get_nncf_wrapped_model(), NNCF_MODULES)\n\n def rebuild_graph(self, *input_args):\n self._compressed_context.reset_graph()\n dummy_forward_fn = self._get_dummy_forward_fn_for_graph_building(with_input_tracing=False)\n builder = GraphBuilder(dummy_forward_fn)\n _ = builder.build_graph(self, self._compressed_context)\n\n def post_build_graph_actions(self):\n # Reset initialization flags (`initialized`) for all quantization modules\n # after dummy `load_state_dict` call.\n quantization_types = [class_type.__name__ for class_type in QUANTIZATION_MODULES.registry_dict.values()]\n all_quantizations = get_state_dict_names_with_modules(self, quantization_types)\n for module in all_quantizations.values():\n module.initialized = False\n\n def get_post_pattern_insertion_points(self, pattern: 'NNCFNodeExpression',\n omit_nodes_in_nncf_modules=False) -> List[InsertionInfo]:\n io_infos = self._original_graph.get_matching_nncf_graph_pattern_io_list(pattern)\n\n insertion_infos = []\n for io_info in io_infos:\n # The input/output is given in terms of edges, but the post-hooks are currently applied to\n # nodes. Multiple output edges in a pattern I/O info may originate from one and the same\n # node, and we have to ensure that these resolve into just one insertion point - thus the usage of \"set\".\n pattern_insertion_info_set = set()\n if len(io_info.output_edges) > 1:\n nncf_logger.debug(\"WARNING: pattern has more than one activation output\")\n\n for nncf_node in io_info.output_nodes:\n pattern_insertion_info_set.add(InsertionInfo(nncf_node.op_exec_context,\n is_output=True,\n shape_to_operate_on=None))\n # TODO: determine output shapes for output nodes to enable per-channel quantization\n\n # Ignore input nodes in the pattern for now, rely on the _quantize_inputs functions.\n # TODO: handle input quantization here as well\n\n # Since this function is currently only used for activation quantization purposes via operator\n # post-hook mechanism, we may take any edge and it will point from the same node where we will have to\n # insert a quantizer later. However, in the future the output edges may refer to activation tensors\n # with different sizes, in which case we have to insert different per-channel quantizers to\n # accomodate different trainable params if there is a difference in the channel dimension.\n # Furthermore, currently there is no distinction for single tensor output to multiple nodes and\n # multiple tensor output to multiple nodes (\"chunk\" operation is an example of the latter).\n # The pattern may also have unexpected outputs from a node in the middle of the pattern (see\n # \"densenet121.dot\" for an example of this) - need to decide what to do with that in terms\n # of quantization.\n # TODO: address the issues above.\n\n for nncf_edge in io_info.output_edges:\n pattern_insertion_info_set.add(InsertionInfo(nncf_edge.from_node.op_exec_context,\n is_output=False,\n shape_to_operate_on=nncf_edge.tensor_shape))\n insertion_infos += list(pattern_insertion_info_set)\n\n insertion_infos = list(\n set(insertion_infos)) # Filter the overlapping insertion points from different matches (happens for GNMT)\n insertion_infos_filtered = []\n\n for info in insertion_infos:\n if omit_nodes_in_nncf_modules and self.is_scope_in_nncf_module_scope(info.op_exec_context.scope_in_model):\n continue\n insertion_infos_filtered.append(info)\n\n return insertion_infos_filtered\n\n def is_scope_in_nncf_module_scope(self, scope: 'Scope'):\n # TODO: optimize\n norm_nncf_scopes = [self._normalize_variable_recurrent_scope(x) for x in self._nncf_module_scopes]\n norm_op_scope = self._normalize_variable_recurrent_scope(scope)\n for nncf_scope in norm_nncf_scopes:\n if norm_op_scope in nncf_scope:\n return True\n return False\n\n def register_compression_module_type(self, compression_module_type: CompressionModuleType):\n attr_name = self._compression_module_type_to_attr_name(compression_module_type)\n if compression_module_type in self._extra_module_types:\n raise RuntimeError(\"Module type {} is already registered\".format(compression_module_type))\n self.__setattr__(attr_name, nn.ModuleDict())\n self._extra_module_types.append(compression_module_type)\n\n def add_compression_module(self, module_key: str, module: nn.Module,\n compression_module_type: CompressionModuleType):\n attr_name = self._compression_module_type_to_attr_name(compression_module_type)\n if compression_module_type not in self._extra_module_types:\n raise RuntimeError(\"Module type {} was not registered\".format(compression_module_type))\n self.__getattr__(attr_name)[module_key] = module\n\n def get_compression_modules_by_type(self, compression_module_type: CompressionModuleType) -> nn.ModuleDict:\n attr_name = self._compression_module_type_to_attr_name(compression_module_type)\n if compression_module_type not in self._extra_module_types:\n raise RuntimeError(\"Module type {} was not registered\".format(compression_module_type))\n return self.__getattr__(attr_name)\n\n @staticmethod\n def _compression_module_type_to_attr_name(compression_module_type: CompressionModuleType):\n \"\"\"Required for backward compatibility with checkpoints that store function and activation\n quantizers directly under corresponding attributes of NNCFNetwork.\"\"\"\n if compression_module_type == CompressionModuleType.FUNCTION_QUANTIZER:\n return \"function_quantizers\"\n if compression_module_type == CompressionModuleType.ACTIVATION_QUANTIZER:\n return \"activation_quantizers\"\n raise RuntimeError(\"Unknown extra module type\")\n\n def sort_compression_modules(self, compression_module_type: CompressionModuleType):\n attr_name = self._compression_module_type_to_attr_name(compression_module_type)\n if compression_module_type not in self._extra_module_types:\n raise RuntimeError(\"Module type {} was not registered\".format(compression_module_type))\n module_dict = self.__getattr__(attr_name)\n # pylint: disable=protected-access\n module_dict._modules = OrderedDict(sorted(module_dict._modules.items()))\n self.__setattr__(attr_name, module_dict)\n\n @staticmethod\n def _normalize_variable_recurrent_scope(scope: 'Scope'):\n \"\"\"\n Two scopes pointing to an NNCF module that only differ in a Recurrent/VariableRecurrent/VariableRecurrentReverse\n scope element actually point to one and the same module.\n \"\"\"\n ret_scope = scope.copy()\n for scope_element in ret_scope:\n if scope_element.calling_module_class_name in [\"Recurrent\", \"VariableRecurrent\",\n \"VariableRecurrentReverse\"]:\n scope_element.calling_module_class_name = \"NormalizedName_Recurrent\"\n return ret_scope\n\n def do_dummy_forward(self, force_eval=False):\n \"\"\"Attention: If run with force_eval=False, this may spoil the batchnorm statistics,\n and an eval run of the model will perform much worse than the train run. \"\"\"\n if force_eval:\n train_mode = self.training\n self.eval()\n with torch.no_grad():\n self._dummy_forward_fn(self)\n if force_eval:\n if train_mode:\n self.train()\n\n def get_insertion_point_graph(self) -> InsertionPointGraph:\n ip_graph = InsertionPointGraph(self._original_graph.get_nx_graph_copy())\n\n # Mark IP graph operator nodes with associated op metatypes\n # Determining operator metatypes is more suited to occur at wrap_operator\n # stage, because it might be influenced by specific non-tensor function paramters,\n # but we have to inspect the containing module parameters as well, so the\n # TracingContext in wrap_operator would have to retain a reference to\n # the model that uses it. Since currently we do not need to inspect the\n # function arguments to determine the metatype, we can do this here, but\n # once we need to inspect the arguments, the code will have to be moved to\n # wrap_operator.\n\n for node_key in ip_graph.nodes:\n ip_graph_node = ip_graph.nodes[node_key]\n ip_graph_node_type = ip_graph_node[InsertionPointGraph.NODE_TYPE_NODE_ATTR]\n if ip_graph_node_type == InsertionPointGraphNodeType.OPERATOR:\n nncf_graph_node_ref = ip_graph_node[InsertionPointGraph.REGULAR_NODE_REF_NODE_ATTR]\n op_exec_context = nncf_graph_node_ref[NNCFGraph.OP_EXEC_CONTEXT_NODE_ATTR]\n op_name = op_exec_context.operator_name\n scope = op_exec_context.scope_in_model\n op_arch = OPERATOR_METATYPES.get_operator_metatype_by_op_name(op_name)\n module = self.get_module_by_scope(scope)\n if module is not None:\n subtype = op_arch.determine_subtype(containing_module=module)\n if subtype is not None:\n op_arch = subtype\n ip_graph_node[InsertionPointGraph.OPERATOR_METATYPE_NODE_ATTR] = op_arch\n return ip_graph\n\n def get_module_by_scope(self, scope: 'Scope') -> torch.nn.Module:\n curr_module = self.get_nncf_wrapped_model()\n for scope_element in scope[1:]: # omit first scope element which corresponds to base module\n if scope_element.calling_field_name is None:\n # The module used is being created in-place every time and never stored in the model,\n # happens for nn.Softmax in BERT implementations.\n return None\n # pylint: disable=protected-access\n next_module = curr_module._modules.get(scope_element.calling_field_name)\n if next_module is None:\n raise RuntimeError(\"Could not find a {} module member in {} module of scope {} during node search\"\n .format(scope_element.calling_field_name,\n scope_element.calling_module_class_name,\n str(scope)))\n curr_module = next_module\n return curr_module\n",
"#!/usr/bin/env python3\n#\n# Copyright (C) 2019 Intel Corporation\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,\n# software 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\n# and limitations under the License.\n\n\"\"\" This script allows you to test Text Recognition model. \"\"\"\n\nimport argparse\n\nimport numpy as np\nimport tensorflow as tf\nfrom tqdm import tqdm\n\nimport cv2\n\nfrom text_recognition.model import TextRecognition\nfrom text_recognition.dataset import Dataset\n\n\ndef parse_args():\n \"\"\" Parases input arguments. \"\"\"\n\n parser = argparse.ArgumentParser()\n parser.add_argument('--annotation_path', required=True, help='Annotation path.')\n parser.add_argument('--weights_path', required=True, help='Model weights path.')\n parser.add_argument('--show', action='store_true', help='Show images.')\n\n return parser.parse_args()\n\n\ndef main():\n \"\"\" Main testing funciton. \"\"\"\n\n args = parse_args()\n\n sequence_length = 30\n image_width = 120\n image_height = 32\n\n dataset = Dataset(args.annotation_path, image_width, image_height, repeat=1)\n next_sample = dataset().make_one_shot_iterator().get_next()\n\n model = TextRecognition(is_training=False, num_classes=dataset.num_classes)\n images_ph = tf.placeholder(tf.float32, [1, image_height, image_width, 1])\n model_out = model(inputdata=images_ph)\n decoded, _ = tf.nn.ctc_beam_search_decoder(model_out, sequence_length * np.ones(1),\n merge_repeated=False)\n\n saver = tf.train.Saver()\n with tf.Session() as sess:\n saver.restore(sess=sess, save_path=args.weights_path)\n\n correct = 0.0\n dataset_len = len(dataset)\n for _ in tqdm(range(dataset_len)):\n images_batch, labels_batch = sess.run(next_sample)\n\n preds, _ = sess.run([decoded, model_out], feed_dict={images_ph: images_batch})\n\n try:\n predicted = Dataset.sparse_tensor_to_str(preds[0], dataset.int_to_char)[0]\n expected = Dataset.sparse_tensor_to_str(labels_batch, dataset.int_to_char)[\n 0].lower()\n except:\n print('Could not find a word')\n continue\n\n correct += 1 if predicted == expected else 0\n\n if args.show and predicted != expected:\n image = np.reshape(images_batch, [image_height, image_width, -1]).astype(np.uint8)\n cv2.imshow('image', image)\n print('pr, gt', predicted, expected)\n k = cv2.waitKey(0)\n if k == 27:\n sess.close()\n return\n\n print('accuracy', correct / dataset_len)\n\n return\n\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"torch.LongTensor",
"torch.nn.functional.cross_entropy",
"torch.nn.functional.smooth_l1_loss",
"torch.Tensor"
],
[
"tensorflow.contrib.slim.l2_regularizer",
"tensorflow.contrib.rnn.stack_bidirectional_dynamic_rnn",
"tensorflow.contrib.slim.max_pool2d",
"tensorflow.contrib.layers.variance_scaling_initializer",
"tensorflow.transpose",
"tensorflow.reshape",
"tensorflow.nn.rnn_cell.LSTMCell",
"tensorflow.variable_scope",
"tensorflow.squeeze",
"tensorflow.contrib.slim.arg_scope",
"tensorflow.contrib.slim.conv2d",
"tensorflow.contrib.slim.fully_connected",
"tensorflow.contrib.slim.batch_norm",
"tensorflow.contrib.slim.dropout"
],
[
"torch.cat",
"torch.nn.LSTM",
"torch.LongTensor",
"torch.nn.utils.rnn.pack_padded_sequence",
"torch.autograd.Variable",
"torch.IntTensor",
"torch.unsqueeze",
"torch.nn.functional.relu",
"torch.nn.functional.tanh",
"torch.zeros",
"torch.device",
"torch.nn.functional.sigmoid",
"torch.nn.LSTMCell",
"torch.nn.utils.rnn.pad_sequence",
"torch.cuda.set_device",
"torch.nn.Conv2d",
"torch.testing.assert_allclose",
"torch.sort",
"torch.rand",
"torch.no_grad",
"torch.randn"
],
[
"matplotlib.use",
"tensorflow.less",
"tensorflow.train.MomentumOptimizer",
"tensorflow.constant",
"tensorflow.train.get_or_create_global_step"
],
[
"torch.nn.ModuleDict",
"torch.no_grad"
],
[
"numpy.reshape",
"tensorflow.Session",
"tensorflow.train.Saver",
"numpy.ones",
"tensorflow.placeholder"
]
] |
CORAL-CMU/kalibr | [
"ebd759286944f156c3ae6202c27fe47667929744"
] | [
"aslam_offline_calibration/kalibr/python/kalibr_camera_calibration/CameraIntializers.py"
] | [
"import sm\nimport aslam_backend as aopt\nimport aslam_cv as cv\nimport numpy as np\n\ndef addPoseDesignVariable(problem, T0=sm.Transformation()):\n q_Dv = aopt.RotationQuaternionDv( T0.q() )\n q_Dv.setActive( True )\n problem.addDesignVariable(q_Dv)\n t_Dv = aopt.EuclideanPointDv( T0.t() )\n t_Dv.setActive( True )\n problem.addDesignVariable(t_Dv)\n return aopt.TransformationBasicDv( q_Dv.toExpression(), t_Dv.toExpression() )\n\ndef stereoCalibrate(camL_geometry, camH_geometry, obslist, distortionActive=False, baseline=None):\n #####################################################\n ## find initial guess as median of all pnp solutions\n #####################################################\n if baseline is None:\n r=[]; t=[]\n for obsL, obsH in obslist:\n #if we have observations for both camss\n if obsL is not None and obsH is not None:\n success, T_L = camL_geometry.geometry.estimateTransformation(obsL)\n success, T_H = camH_geometry.geometry.estimateTransformation(obsH)\n \n baseline = T_H.inverse()*T_L\n t.append(baseline.t())\n rv=sm.RotationVector()\n r.append(rv.rotationMatrixToParameters( baseline.C() ))\n \n r_median = np.median(np.asmatrix(r), axis=0).flatten().T\n R_median = rv.parametersToRotationMatrix(r_median)\n t_median = np.median(np.asmatrix(t), axis=0).flatten().T\n \n baseline_HL = sm.Transformation( sm.rt2Transform(R_median, t_median) )\n else:\n baseline_HL = baseline\n \n #verbose output\n if sm.getLoggingLevel()==sm.LoggingLevel.Debug:\n dL = camL_geometry.geometry.projection().distortion().getParameters().flatten()\n pL = camL_geometry.geometry.projection().getParameters().flatten()\n dH = camH_geometry.geometry.projection().distortion().getParameters().flatten()\n pH = camH_geometry.geometry.projection().getParameters().flatten()\n sm.logDebug(\"initial guess for stereo calib: {0}\".format(baseline_HL.T()))\n sm.logDebug(\"initial guess for intrinsics camL: {0}\".format(pL))\n sm.logDebug(\"initial guess for intrinsics camH: {0}\".format(pH))\n sm.logDebug(\"initial guess for distortion camL: {0}\".format(dL))\n sm.logDebug(\"initial guess for distortion camH: {0}\".format(dH)) \n \n ############################################\n ## solve the bundle adjustment\n ############################################\n problem = aopt.OptimizationProblem()\n\n #baseline design variable \n baseline_dv = addPoseDesignVariable(problem, baseline_HL)\n \n #target pose dv for all target views (=T_camL_w)\n target_pose_dvs = list()\n for obsL, obsH in obslist:\n if obsL is not None: #use camL if we have an obs for this one\n success, T_t_cL = camL_geometry.geometry.estimateTransformation(obsL)\n else:\n success, T_t_cH = camH_geometry.geometry.estimateTransformation(obsH)\n T_t_cL = T_t_cH*baseline_HL #apply baseline for the second camera\n \n target_pose_dv = addPoseDesignVariable(problem, T_t_cL)\n target_pose_dvs.append(target_pose_dv)\n \n #add camera dvs\n camL_geometry.setDvActiveStatus(camL_geometry.projectionActive, distortionActive or camL_geometry.distortionActive, False)\n camH_geometry.setDvActiveStatus(camH_geometry.projectionActive, distortionActive or camH_geometry.distortionActive, False)\n problem.addDesignVariable(camL_geometry.dv.distortionDesignVariable())\n problem.addDesignVariable(camL_geometry.dv.projectionDesignVariable())\n problem.addDesignVariable(camL_geometry.dv.shutterDesignVariable())\n problem.addDesignVariable(camH_geometry.dv.distortionDesignVariable())\n problem.addDesignVariable(camH_geometry.dv.projectionDesignVariable())\n problem.addDesignVariable(camH_geometry.dv.shutterDesignVariable())\n \n ############################################\n ## add error terms\n ############################################\n \n #corner uncertainty\n # \\todo pass in the detector uncertainty somehow.\n cornerUncertainty = 1.0\n R = np.eye(2) * cornerUncertainty * cornerUncertainty\n invR = np.linalg.inv(R)\n \n #Add reprojection error terms for both cameras\n reprojectionErrors0 = []; reprojectionErrors1 = []\n \n for cidx, cam in enumerate([camL_geometry, camH_geometry]):\n sm.logDebug(\"stereoCalibration: adding camera error terms for {0} calibration targets\".format(len(obslist)))\n\n #get the image and target points corresponding to the frame\n target = cam.ctarget.detector.target()\n \n #add error terms for all observations\n for view_id, obstuple in enumerate(obslist):\n \n #add error terms if we have an observation for this cam\n obs=obstuple[cidx]\n if obs is not None:\n T_cam_w = target_pose_dvs[view_id].toExpression().inverse()\n \n #add the baseline for the second camera\n if cidx!=0:\n T_cam_w = baseline_dv.toExpression() * T_cam_w\n \n for i in range(0, target.size()):\n p_target = aopt.HomogeneousExpression(sm.toHomogeneous(target.point(i)));\n valid, y = obs.imagePoint(i)\n if valid:\n # Create an error term.\n rerr = cam.model.reprojectionError(y, invR, T_cam_w * p_target, cam.dv)\n rerr.idx = i\n problem.addErrorTerm(rerr)\n \n if cidx==0:\n reprojectionErrors0.append(rerr)\n else:\n reprojectionErrors1.append(rerr)\n \n sm.logDebug(\"stereoCalibrate: added {0} camera error terms\".format( len(reprojectionErrors0)+len(reprojectionErrors1) ))\n \n ############################################\n ## solve\n ############################################ \n options = aopt.Optimizer2Options()\n options.verbose = True if sm.getLoggingLevel()==sm.LoggingLevel.Debug else False\n options.nThreads = 4\n options.convergenceDeltaX = 1e-3\n options.convergenceDeltaJ = 1\n options.maxIterations = 200\n options.trustRegionPolicy = aopt.LevenbergMarquardtTrustRegionPolicy(10)\n\n optimizer = aopt.Optimizer2(options)\n optimizer.setProblem(problem)\n\n #verbose output\n if sm.getLoggingLevel()==sm.LoggingLevel.Debug:\n sm.logDebug(\"Before optimization:\")\n e2 = np.array([ e.evaluateError() for e in reprojectionErrors0 ])\n sm.logDebug( \" Reprojection error squarred (camL): mean {0}, median {1}, std: {2}\".format(np.mean(e2), np.median(e2), np.std(e2) ) )\n e2 = np.array([ e.evaluateError() for e in reprojectionErrors1 ])\n sm.logDebug( \" Reprojection error squarred (camH): mean {0}, median {1}, std: {2}\".format(np.mean(e2), np.median(e2), np.std(e2) ) )\n \n sm.logDebug(\"baseline={0}\".format(baseline_dv.toTransformationMatrix()))\n \n try: \n retval = optimizer.optimize()\n if retval.linearSolverFailure:\n sm.logError(\"stereoCalibrate: Optimization failed!\")\n success = not retval.linearSolverFailure\n except:\n sm.logError(\"stereoCalibrate: Optimization failed!\")\n success = False\n \n if sm.getLoggingLevel()==sm.LoggingLevel.Debug:\n sm.logDebug(\"After optimization:\")\n e2 = np.array([ e.evaluateError() for e in reprojectionErrors0 ])\n sm.logDebug( \" Reprojection error squarred (camL): mean {0}, median {1}, std: {2}\".format(np.mean(e2), np.median(e2), np.std(e2) ) )\n e2 = np.array([ e.evaluateError() for e in reprojectionErrors1 ])\n sm.logDebug( \" Reprojection error squarred (camH): mean {0}, median {1}, std: {2}\".format(np.mean(e2), np.median(e2), np.std(e2) ) )\n \n #verbose output\n if sm.getLoggingLevel()==sm.LoggingLevel.Debug:\n dL = camL_geometry.geometry.projection().distortion().getParameters().flatten()\n pL = camL_geometry.geometry.projection().getParameters().flatten()\n dH = camH_geometry.geometry.projection().distortion().getParameters().flatten()\n pH = camH_geometry.geometry.projection().getParameters().flatten()\n sm.logDebug(\"guess for intrinsics camL: {0}\".format(pL))\n sm.logDebug(\"guess for intrinsics camH: {0}\".format(pH))\n sm.logDebug(\"guess for distortion camL: {0}\".format(dL))\n sm.logDebug(\"guess for distortion camH: {0}\".format(dH)) \n \n if success:\n baseline_HL = sm.Transformation(baseline_dv.toTransformationMatrix())\n return success, baseline_HL\n else:\n #return the intiial guess if we fail\n return success, baseline_HL\n\n\ndef calibrateIntrinsics(cam_geometry, obslist, distortionActive=True, intrinsicsActive=True):\n #verbose output\n if sm.getLoggingLevel()==sm.LoggingLevel.Debug:\n d = cam_geometry.geometry.projection().distortion().getParameters().flatten()\n p = cam_geometry.geometry.projection().getParameters().flatten()\n sm.logDebug(\"calibrateIntrinsics: intrinsics guess: {0}\".format(p))\n sm.logDebug(\"calibrateIntrinsics: distortion guess: {0}\".format(d))\n \n ############################################\n ## solve the bundle adjustment\n ############################################\n problem = aopt.OptimizationProblem()\n \n #add camera dvs\n cam_geometry.setDvActiveStatus(intrinsicsActive, distortionActive, False)\n problem.addDesignVariable(cam_geometry.dv.distortionDesignVariable())\n problem.addDesignVariable(cam_geometry.dv.projectionDesignVariable())\n problem.addDesignVariable(cam_geometry.dv.shutterDesignVariable())\n \n #corner uncertainty\n cornerUncertainty = 1.0\n R = np.eye(2) * cornerUncertainty * cornerUncertainty\n invR = np.linalg.inv(R)\n \n #get the image and target points corresponding to the frame\n target = cam_geometry.ctarget.detector.target()\n \n #target pose dv for all target views (=T_camL_w)\n reprojectionErrors = []; \n sm.logDebug(\"calibrateIntrinsics: adding camera error terms for {0} calibration targets\".format(len(obslist)))\n target_pose_dvs=list()\n for obs in obslist: \n success, T_t_c = cam_geometry.geometry.estimateTransformation(obs)\n target_pose_dv = addPoseDesignVariable(problem, T_t_c)\n target_pose_dvs.append(target_pose_dv)\n \n T_cam_w = target_pose_dv.toExpression().inverse()\n \n ## add error terms\n for i in range(0, target.size()):\n p_target = aopt.HomogeneousExpression(sm.toHomogeneous(target.point(i)));\n valid, y = obs.imagePoint(i)\n if valid:\n rerr = cam_geometry.model.reprojectionError(y, invR, T_cam_w * p_target, cam_geometry.dv)\n problem.addErrorTerm(rerr)\n reprojectionErrors.append(rerr)\n \n sm.logDebug(\"calibrateIntrinsics: added {0} camera error terms\".format(len(reprojectionErrors)))\n \n ############################################\n ## solve\n ############################################ \n options = aopt.Optimizer2Options()\n options.verbose = True if sm.getLoggingLevel()==sm.LoggingLevel.Debug else False\n options.nThreads = 4\n options.convergenceDeltaX = 1e-3\n options.convergenceDeltaJ = 1\n options.maxIterations = 200\n options.trustRegionPolicy = aopt.LevenbergMarquardtTrustRegionPolicy(10)\n\n optimizer = aopt.Optimizer2(options)\n optimizer.setProblem(problem)\n\n #verbose output\n if sm.getLoggingLevel()==sm.LoggingLevel.Debug:\n sm.logDebug(\"Before optimization:\")\n e2 = np.array([ e.evaluateError() for e in reprojectionErrors ])\n sm.logDebug( \" Reprojection error squarred (camL): mean {0}, median {1}, std: {2}\".format(np.mean(e2), np.median(e2), np.std(e2) ) )\n \n #run intrinsic calibration\n try: \n retval = optimizer.optimize()\n if retval.linearSolverFailure:\n sm.logError(\"calibrateIntrinsics: Optimization failed!\")\n success = not retval.linearSolverFailure\n\n except:\n sm.logError(\"calibrateIntrinsics: Optimization failed!\")\n success = False\n \n #verbose output\n if sm.getLoggingLevel()==sm.LoggingLevel.Debug:\n d = cam_geometry.geometry.projection().distortion().getParameters().flatten()\n p = cam_geometry.geometry.projection().getParameters().flatten()\n sm.logDebug(\"calibrateIntrinsics: guess for intrinsics cam: {0}\".format(p))\n sm.logDebug(\"calibrateIntrinsics: guess for distortion cam: {0}\".format(d))\n \n return success\n\n\ndef solveFullBatch(cameras, baseline_guesses, graph): \n ############################################\n ## solve the bundle adjustment\n ############################################\n problem = aopt.OptimizationProblem()\n \n #add camera dvs\n for cam in cameras:\n cam.setDvActiveStatus(cam.projectionActive, cam.distortionActive, False)\n problem.addDesignVariable(cam.dv.distortionDesignVariable())\n problem.addDesignVariable(cam.dv.projectionDesignVariable())\n problem.addDesignVariable(cam.dv.shutterDesignVariable())\n \n baseline_dvs = list()\n for baseline_idx in range(0, len(cameras)-1): \n baseline_dv = aopt.TransformationDv(baseline_guesses[baseline_idx])\n \n for i in range(0, baseline_dv.numDesignVariables()):\n problem.addDesignVariable(baseline_dv.getDesignVariable(i))\n \n baseline_dvs.append( baseline_dv )\n \n #corner uncertainty\n cornerUncertainty = 1.0\n R = np.eye(2) * cornerUncertainty * cornerUncertainty\n invR = np.linalg.inv(R)\n \n #get the target\n target = cameras[0].ctarget.detector.target()\n\n #Add calibration target reprojection error terms for all camera in chain\n target_pose_dvs = list()\n \n #shuffle the views\n reprojectionErrors = []; \n timestamps = graph.obs_db.getAllViewTimestamps()\n for view_id, timestamp in enumerate(timestamps):\n \n #get all observations for all cams at this time\n obs_tuple = graph.obs_db.getAllObsAtTimestamp(timestamp)\n\n #create a target pose dv for all target views (= T_cam0_w)\n T0 = graph.getTargetPoseGuess(timestamp, cameras, baseline_guesses)\n target_pose_dv = addPoseDesignVariable(problem, T0)\n target_pose_dvs.append(target_pose_dv)\n \n\n for cidx, obs in obs_tuple:\n cam = cameras[cidx]\n \n #calibration target coords to camera X coords\n T_cam0_calib = target_pose_dv.toExpression().inverse()\n\n #build pose chain (target->cam0->baselines->camN)\n T_camN_calib = T_cam0_calib\n for idx in range(0, cidx):\n T_camN_calib = baseline_dvs[idx].toExpression() * T_camN_calib\n \n \n ## add error terms\n for i in range(0, target.size()):\n p_target = aopt.HomogeneousExpression(sm.toHomogeneous(target.point(i)));\n valid, y = obs.imagePoint(i)\n if valid:\n rerr = cameras[cidx].model.reprojectionError(y, invR, T_camN_calib * p_target, cameras[cidx].dv)\n problem.addErrorTerm(rerr)\n reprojectionErrors.append(rerr)\n \n sm.logDebug(\"solveFullBatch: added {0} camera error terms\".format(len(reprojectionErrors)))\n \n ############################################\n ## solve\n ############################################ \n options = aopt.Optimizer2Options()\n options.verbose = True if sm.getLoggingLevel()==sm.LoggingLevel.Debug else False\n options.nThreads = 4\n options.convergenceDeltaX = 1e-3\n options.convergenceDeltaJ = 1\n options.maxIterations = 250\n options.trustRegionPolicy = aopt.LevenbergMarquardtTrustRegionPolicy(10)\n\n optimizer = aopt.Optimizer2(options)\n optimizer.setProblem(problem)\n\n #verbose output\n if sm.getLoggingLevel()==sm.LoggingLevel.Debug:\n sm.logDebug(\"Before optimization:\")\n e2 = np.array([ e.evaluateError() for e in reprojectionErrors ])\n sm.logDebug( \" Reprojection error squarred (camL): mean {0}, median {1}, std: {2}\".format(np.mean(e2), np.median(e2), np.std(e2) ) )\n \n #run intrinsic calibration\n try:\n retval = optimizer.optimize()\n if retval.linearSolverFailure:\n sm.logError(\"calibrateIntrinsics: Optimization failed!\")\n success = not retval.linearSolverFailure\n\n except:\n sm.logError(\"calibrateIntrinsics: Optimization failed!\")\n success = False\n\n baselines=list()\n for baseline_dv in baseline_dvs:\n baselines.append( sm.Transformation(baseline_dv.T()) )\n \n return success, baselines\n\n"
] | [
[
"numpy.asmatrix",
"numpy.median",
"numpy.mean",
"numpy.eye",
"numpy.std",
"numpy.linalg.inv"
]
] |
ymaxgit/mxnet | [
"01ae629c6593e0352fd30979bccd0196854ef882"
] | [
"tests/python/unittest/test_gluon_rnn.py"
] | [
"# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\nimport mxnet as mx\nfrom mxnet import gluon\nimport numpy as np\nfrom numpy.testing import assert_allclose\nimport unittest\nfrom mxnet.test_utils import almost_equal\n\n\ndef test_rnn():\n cell = gluon.rnn.RNNCell(100, prefix='rnn_')\n inputs = [mx.sym.Variable('rnn_t%d_data'%i) for i in range(3)]\n outputs, _ = cell.unroll(3, inputs)\n outputs = mx.sym.Group(outputs)\n assert sorted(cell.collect_params().keys()) == ['rnn_h2h_bias', 'rnn_h2h_weight', 'rnn_i2h_bias', 'rnn_i2h_weight']\n assert outputs.list_outputs() == ['rnn_t0_out_output', 'rnn_t1_out_output', 'rnn_t2_out_output']\n\n args, outs, auxs = outputs.infer_shape(rnn_t0_data=(10,50), rnn_t1_data=(10,50), rnn_t2_data=(10,50))\n assert outs == [(10, 100), (10, 100), (10, 100)]\n\n\ndef test_lstm():\n cell = gluon.rnn.LSTMCell(100, prefix='rnn_')\n inputs = [mx.sym.Variable('rnn_t%d_data'%i) for i in range(3)]\n outputs, _ = cell.unroll(3, inputs)\n outputs = mx.sym.Group(outputs)\n assert sorted(cell.collect_params().keys()) == ['rnn_h2h_bias', 'rnn_h2h_weight', 'rnn_i2h_bias', 'rnn_i2h_weight']\n assert outputs.list_outputs() == ['rnn_t0_out_output', 'rnn_t1_out_output', 'rnn_t2_out_output']\n\n args, outs, auxs = outputs.infer_shape(rnn_t0_data=(10,50), rnn_t1_data=(10,50), rnn_t2_data=(10,50))\n assert outs == [(10, 100), (10, 100), (10, 100)]\n\n\ndef test_lstm_forget_bias():\n forget_bias = 2.0\n stack = gluon.rnn.SequentialRNNCell()\n stack.add(gluon.rnn.LSTMCell(100, i2h_bias_initializer=mx.init.LSTMBias(forget_bias), prefix='l0_'))\n stack.add(gluon.rnn.LSTMCell(100, i2h_bias_initializer=mx.init.LSTMBias(forget_bias), prefix='l1_'))\n\n dshape = (32, 1, 200)\n data = mx.sym.Variable('data')\n\n sym, _ = stack.unroll(1, data, merge_outputs=True)\n mod = mx.mod.Module(sym, label_names=None, context=mx.cpu(0))\n mod.bind(data_shapes=[('data', dshape)], label_shapes=None)\n\n mod.init_params()\n\n bias_argument = next(x for x in sym.list_arguments() if x.endswith('i2h_bias'))\n expected_bias = np.hstack([np.zeros((100,)),\n forget_bias * np.ones(100, ), np.zeros((2 * 100,))])\n assert_allclose(mod.get_params()[0][bias_argument].asnumpy(), expected_bias)\n\n\ndef test_gru():\n cell = gluon.rnn.GRUCell(100, prefix='rnn_')\n inputs = [mx.sym.Variable('rnn_t%d_data'%i) for i in range(3)]\n outputs, _ = cell.unroll(3, inputs)\n outputs = mx.sym.Group(outputs)\n assert sorted(cell.collect_params().keys()) == ['rnn_h2h_bias', 'rnn_h2h_weight', 'rnn_i2h_bias', 'rnn_i2h_weight']\n assert outputs.list_outputs() == ['rnn_t0_out_output', 'rnn_t1_out_output', 'rnn_t2_out_output']\n\n args, outs, auxs = outputs.infer_shape(rnn_t0_data=(10,50), rnn_t1_data=(10,50), rnn_t2_data=(10,50))\n assert outs == [(10, 100), (10, 100), (10, 100)]\n\n\ndef test_residual():\n cell = gluon.rnn.ResidualCell(gluon.rnn.GRUCell(50, prefix='rnn_'))\n inputs = [mx.sym.Variable('rnn_t%d_data'%i) for i in range(2)]\n outputs, _ = cell.unroll(2, inputs)\n outputs = mx.sym.Group(outputs)\n assert sorted(cell.collect_params().keys()) == \\\n ['rnn_h2h_bias', 'rnn_h2h_weight', 'rnn_i2h_bias', 'rnn_i2h_weight']\n # assert outputs.list_outputs() == \\\n # ['rnn_t0_out_plus_residual_output', 'rnn_t1_out_plus_residual_output']\n\n args, outs, auxs = outputs.infer_shape(rnn_t0_data=(10, 50), rnn_t1_data=(10, 50))\n assert outs == [(10, 50), (10, 50)]\n outputs = outputs.eval(rnn_t0_data=mx.nd.ones((10, 50)),\n rnn_t1_data=mx.nd.ones((10, 50)),\n rnn_i2h_weight=mx.nd.zeros((150, 50)),\n rnn_i2h_bias=mx.nd.zeros((150,)),\n rnn_h2h_weight=mx.nd.zeros((150, 50)),\n rnn_h2h_bias=mx.nd.zeros((150,)))\n expected_outputs = np.ones((10, 50))\n assert np.array_equal(outputs[0].asnumpy(), expected_outputs)\n assert np.array_equal(outputs[1].asnumpy(), expected_outputs)\n\n\ndef test_residual_bidirectional():\n cell = gluon.rnn.ResidualCell(\n gluon.rnn.BidirectionalCell(\n gluon.rnn.GRUCell(25, prefix='rnn_l_'),\n gluon.rnn.GRUCell(25, prefix='rnn_r_')))\n\n inputs = [mx.sym.Variable('rnn_t%d_data'%i) for i in range(2)]\n outputs, _ = cell.unroll(2, inputs, merge_outputs=False)\n outputs = mx.sym.Group(outputs)\n assert sorted(cell.collect_params().keys()) == \\\n ['rnn_l_h2h_bias', 'rnn_l_h2h_weight', 'rnn_l_i2h_bias', 'rnn_l_i2h_weight',\n 'rnn_r_h2h_bias', 'rnn_r_h2h_weight', 'rnn_r_i2h_bias', 'rnn_r_i2h_weight']\n # assert outputs.list_outputs() == \\\n # ['bi_t0_plus_residual_output', 'bi_t1_plus_residual_output']\n\n args, outs, auxs = outputs.infer_shape(rnn_t0_data=(10, 50), rnn_t1_data=(10, 50))\n assert outs == [(10, 50), (10, 50)]\n outputs = outputs.eval(rnn_t0_data=mx.nd.ones((10, 50))+5,\n rnn_t1_data=mx.nd.ones((10, 50))+5,\n rnn_l_i2h_weight=mx.nd.zeros((75, 50)),\n rnn_l_i2h_bias=mx.nd.zeros((75,)),\n rnn_l_h2h_weight=mx.nd.zeros((75, 25)),\n rnn_l_h2h_bias=mx.nd.zeros((75,)),\n rnn_r_i2h_weight=mx.nd.zeros((75, 50)),\n rnn_r_i2h_bias=mx.nd.zeros((75,)),\n rnn_r_h2h_weight=mx.nd.zeros((75, 25)),\n rnn_r_h2h_bias=mx.nd.zeros((75,)))\n expected_outputs = np.ones((10, 50))+5\n assert np.array_equal(outputs[0].asnumpy(), expected_outputs)\n assert np.array_equal(outputs[1].asnumpy(), expected_outputs)\n\n\ndef test_stack():\n cell = gluon.rnn.SequentialRNNCell()\n for i in range(5):\n if i == 1:\n cell.add(gluon.rnn.ResidualCell(gluon.rnn.LSTMCell(100, prefix='rnn_stack%d_' % i)))\n else:\n cell.add(gluon.rnn.LSTMCell(100, prefix='rnn_stack%d_'%i))\n inputs = [mx.sym.Variable('rnn_t%d_data'%i) for i in range(3)]\n outputs, _ = cell.unroll(3, inputs)\n outputs = mx.sym.Group(outputs)\n keys = sorted(cell.collect_params().keys())\n for i in range(5):\n assert 'rnn_stack%d_h2h_weight'%i in keys\n assert 'rnn_stack%d_h2h_bias'%i in keys\n assert 'rnn_stack%d_i2h_weight'%i in keys\n assert 'rnn_stack%d_i2h_bias'%i in keys\n assert outputs.list_outputs() == ['rnn_stack4_t0_out_output', 'rnn_stack4_t1_out_output', 'rnn_stack4_t2_out_output']\n\n args, outs, auxs = outputs.infer_shape(rnn_t0_data=(10,50), rnn_t1_data=(10,50), rnn_t2_data=(10,50))\n assert outs == [(10, 100), (10, 100), (10, 100)]\n\n\ndef test_bidirectional():\n cell = gluon.rnn.BidirectionalCell(\n gluon.rnn.LSTMCell(100, prefix='rnn_l0_'),\n gluon.rnn.LSTMCell(100, prefix='rnn_r0_'),\n output_prefix='rnn_bi_')\n inputs = [mx.sym.Variable('rnn_t%d_data'%i) for i in range(3)]\n outputs, _ = cell.unroll(3, inputs)\n outputs = mx.sym.Group(outputs)\n assert outputs.list_outputs() == ['rnn_bi_t0_output', 'rnn_bi_t1_output', 'rnn_bi_t2_output']\n\n args, outs, auxs = outputs.infer_shape(rnn_t0_data=(10,50), rnn_t1_data=(10,50), rnn_t2_data=(10,50))\n assert outs == [(10, 200), (10, 200), (10, 200)]\n\n\ndef test_zoneout():\n cell = gluon.rnn.ZoneoutCell(gluon.rnn.RNNCell(100, prefix='rnn_'), zoneout_outputs=0.5,\n zoneout_states=0.5)\n inputs = [mx.sym.Variable('rnn_t%d_data'%i) for i in range(3)]\n outputs, _ = cell.unroll(3, inputs)\n outputs = mx.sym.Group(outputs)\n\n args, outs, auxs = outputs.infer_shape(rnn_t0_data=(10,50), rnn_t1_data=(10,50), rnn_t2_data=(10,50))\n assert outs == [(10, 100), (10, 100), (10, 100)]\n\n\ndef check_rnn_forward(layer, inputs, deterministic=True):\n inputs.attach_grad()\n layer.collect_params().initialize()\n with mx.autograd.record():\n out = layer.unroll(3, inputs, merge_outputs=False)[0]\n mx.autograd.backward(out)\n out = layer.unroll(3, inputs, merge_outputs=True)[0]\n out.backward()\n\n np_out = out.asnumpy()\n np_dx = inputs.grad.asnumpy()\n\n layer.hybridize()\n\n with mx.autograd.record():\n out = layer.unroll(3, inputs, merge_outputs=False)[0]\n mx.autograd.backward(out)\n out = layer.unroll(3, inputs, merge_outputs=True)[0]\n out.backward()\n\n if deterministic:\n mx.test_utils.assert_almost_equal(np_out, out.asnumpy(), rtol=1e-3, atol=1e-5)\n mx.test_utils.assert_almost_equal(np_dx, inputs.grad.asnumpy(), rtol=1e-3, atol=1e-5)\n\n\ndef test_rnn_cells():\n check_rnn_forward(gluon.rnn.LSTMCell(100, input_size=200), mx.nd.ones((8, 3, 200)))\n check_rnn_forward(gluon.rnn.RNNCell(100, input_size=200), mx.nd.ones((8, 3, 200)))\n check_rnn_forward(gluon.rnn.GRUCell(100, input_size=200), mx.nd.ones((8, 3, 200)))\n\n bilayer = gluon.rnn.BidirectionalCell(gluon.rnn.LSTMCell(100, input_size=200),\n gluon.rnn.LSTMCell(100, input_size=200))\n check_rnn_forward(bilayer, mx.nd.ones((8, 3, 200)))\n\n check_rnn_forward(gluon.rnn.DropoutCell(0.5), mx.nd.ones((8, 3, 200)), False)\n\n check_rnn_forward(gluon.rnn.ZoneoutCell(gluon.rnn.LSTMCell(100, input_size=200),\n 0.5, 0.2),\n mx.nd.ones((8, 3, 200)), False)\n\n net = gluon.rnn.SequentialRNNCell()\n net.add(gluon.rnn.LSTMCell(100, input_size=200))\n net.add(gluon.rnn.RNNCell(100, input_size=100))\n net.add(gluon.rnn.GRUCell(100, input_size=100))\n check_rnn_forward(net, mx.nd.ones((8, 3, 200)))\n\ndef check_rnn_layer_forward(layer, inputs, states=None):\n layer.collect_params().initialize()\n inputs.attach_grad()\n with mx.autograd.record():\n out = layer(inputs, states)\n if states is not None:\n assert isinstance(out, tuple) and len(out) == 2\n out = out[0]\n else:\n assert isinstance(out, mx.nd.NDArray)\n out.backward()\n\n np_out = out.asnumpy()\n np_dx = inputs.grad.asnumpy()\n\n layer.hybridize()\n\n with mx.autograd.record():\n out = layer(inputs, states)\n if states is not None:\n assert isinstance(out, tuple) and len(out) == 2\n out = out[0]\n else:\n assert isinstance(out, mx.nd.NDArray)\n out.backward()\n\n mx.test_utils.assert_almost_equal(np_out, out.asnumpy(), rtol=1e-3, atol=1e-5)\n mx.test_utils.assert_almost_equal(np_dx, inputs.grad.asnumpy(), rtol=1e-3, atol=1e-5)\n\ndef test_rnn_layers():\n check_rnn_layer_forward(gluon.rnn.RNN(10, 2), mx.nd.ones((8, 3, 20)))\n check_rnn_layer_forward(gluon.rnn.RNN(10, 2), mx.nd.ones((8, 3, 20)), mx.nd.ones((2, 3, 10)))\n check_rnn_layer_forward(gluon.rnn.LSTM(10, 2), mx.nd.ones((8, 3, 20)))\n check_rnn_layer_forward(gluon.rnn.LSTM(10, 2), mx.nd.ones((8, 3, 20)), [mx.nd.ones((2, 3, 10)), mx.nd.ones((2, 3, 10))])\n check_rnn_layer_forward(gluon.rnn.GRU(10, 2), mx.nd.ones((8, 3, 20)))\n check_rnn_layer_forward(gluon.rnn.GRU(10, 2), mx.nd.ones((8, 3, 20)), mx.nd.ones((2, 3, 10)))\n\n net = gluon.nn.Sequential()\n net.add(gluon.rnn.LSTM(10, 2, bidirectional=True))\n net.add(gluon.nn.BatchNorm(axis=2))\n net.add(gluon.nn.Flatten())\n net.add(gluon.nn.Dense(3, activation='relu'))\n net.collect_params().initialize()\n with mx.autograd.record():\n net(mx.nd.ones((2, 3, 10))).backward()\n\n\nif __name__ == '__main__':\n import nose\n nose.runmodule()\n"
] | [
[
"numpy.ones",
"numpy.zeros"
]
] |
lamsoa729/FoXlink | [
"3c061b02968cdab1def752d5c145a6df4615504b"
] | [
"foxlink/me_zrl_bound_evolvers.py"
] | [
"#!/usr/bin/env python\n\n\"\"\"@package docstring\nFile: me_zrl_bound_evolvers.py\nAuthor: Adam Lamson\nEmail: [email protected]\nDescription:\n\"\"\"\n\nimport numpy as np\n# from scipy.integrate import dblquad\nfrom .me_helpers import dr_dt, convert_sol_to_geom\nfrom .me_zrl_odes import (rod_geom_derivs_zrl, calc_moment_derivs_zrl,\n calc_moment_derivs_zrl_B_terms,\n calc_boundary_derivs_zrl)\nfrom .me_zrl_helpers import (avg_force_zrl,\n prep_zrl_bound_evolver,\n get_zrl_moments_and_boundary_terms)\nfrom .rod_steric_forces import calc_wca_force_torque\nfrom .me_zrl_evolvers import prep_zrl_evolver\n\n\ndef evolver_zrl_bound(sol, fric_coeff, params):\n \"\"\"!Calculate all time derivatives necessary to solve the moment expansion\n evolution of the Fokker-Planck equation of zero rest length (zrl) crosslinkers\nbound to moving rods. d<var> is the time derivative of corresponding\nvariable\n\n @param sol: Solution vector to solve_ivp\n @param fric_coeff: friction coefficients of rod\n @param params: Constant parameters of the simulation\n @return: Time-derivatives of all time varying quantities in a flattened\n array\n \"\"\"\n # Define useful parameters for functions\n hL_i, hL_j = (.5 * params['L_i'], .5 * params['L_j'])\n ks = params['ks']\n r_i, r_j, u_i, u_j = convert_sol_to_geom(sol)\n r_ij = r_j - r_i\n\n (scalar_geom, q_arr, Q_arr) = prep_zrl_bound_evolver(sol, params)\n (mu_kl, B_terms) = get_zrl_moments_and_boundary_terms(sol)\n if mu_kl[0] < 0.:\n mu_kl[0] = 0.\n if mu_kl[4] < 0.:\n mu_kl[4] = 0.\n if mu_kl[5] < 0.:\n mu_kl[5] = 0.\n\n # Get average force of crosslinkers on rod2\n f_ij = avg_force_zrl(r_ij, u_i, u_j, mu_kl[0], mu_kl[1], mu_kl[2], ks)\n # Evolution of rod positions\n dgeom = rod_geom_derivs_zrl(f_ij, r_ij, u_i, u_j, scalar_geom,\n mu_kl, fric_coeff, ks)\n\n # Evolution of moments\n dmu_kl = calc_moment_derivs_zrl_B_terms(mu_kl, scalar_geom,\n q_arr, B_terms, params)\n\n # Evolution of boundary condtions\n dB_terms = calc_boundary_derivs_zrl(B_terms, scalar_geom, Q_arr, params)\n dsol = np.concatenate(dgeom, dmu_kl, dB_terms)\n return dsol\n\n##########################################\n"
] | [
[
"numpy.concatenate"
]
] |
shuishoudage/music_generator | [
"7c17ef5bb3a5d872bff5ac8e1664f57f5b4ea08f"
] | [
"data_clean/preprocessing.py"
] | [
"from typing import List, Tuple, Dict, Any\nfrom collections import Counter\nimport pretty_midi\nimport matplotlib.pyplot as plt\nimport librosa.display\nimport os\nfrom os import listdir, walk\nfrom os.path import isfile, isdir, join\nfrom sys import argv\nimport traceback\nimport logging\nimport numpy as np\nfrom shutil import copyfile\nimport shutil\n\n\n# Ideas behind the preprocessing class\n#\n# 1. only use those midi with one tempo and one key, since some midi music\n# have key and tempo changes inside. Which might make some unpredictable result\n#\n# 2. list distribution for all keys contained in the corpus. Only select those\n# most frequent appeared. (different keys may increase training difficulty)\n#\n# 3. only select similar tempo music, based on the mean and std of tempos,\n# simple one will be left boundary = mean - std, right boundary = mean + std\n#\n# 4. find the mean of highest and lowest pitch in the corpus. filter out those not\n# the range. We have pitch range from 0-128, no meaning cover two extreme sides.\nclass FileReport(object):\n \"\"\"\n This class is mainly for generating meta information for our report\n \"\"\"\n\n def __init__(self,\n tempos: List[float],\n freq_key: Dict[int, int],\n min_pitch: List[int],\n max_pitch: List[int]):\n self.tempos = tempos\n self.freq_key = freq_key\n self.min_pitch = min_pitch\n self.max_pitch = max_pitch\n\n def aggregation_report(self):\n \"\"\"\n two important variable are min_pitch and max_pitch,\n since they will be used to decode from pitch to audio\n \"\"\"\n temp_mean = np.array(self.tempos).mean()\n temp_std = np.array(self.tempos).std()\n most_freq_key = self.getMostFreqValue(self.freq_key)\n min_pitch = int(np.array(self.min_pitch).mean())\n max_pitch = int(np.array(self.max_pitch).mean())\n return temp_mean, temp_std, most_freq_key, min_pitch, max_pitch\n\n def plots(self):\n # implement later on\n pass\n\n def getMostFreqValue(self, keys: Dict[int, int], reversed=True) -> int:\n return sorted(keys.items(), key=lambda kv: kv[1], reverse=reversed)[0][0]\n\n\nclass Preprocess(object):\n def __init__(self, path: str):\n self.path = path\n self.fileFilter()\n\n def generateMidiFileReport(self) -> FileReport:\n \"\"\"\n meta information like tempos, keys, pitches will be generated for\n filtering the midi files\n \"\"\"\n tempos = []\n keys = []\n max_pitchs = []\n min_pitchs = []\n for pm in self.pms:\n try:\n tempos.append(pm.estimate_tempo())\n key = pm.key_signature_changes[0].key_number\n keys.append(key)\n min_pitch, max_pitch = self.getMinMaxPitch(pm)\n max_pitchs.append(max_pitch)\n min_pitchs.append(min_pitch)\n except:\n pass\n self.report = FileReport(tempos, dict(\n Counter(keys)), min_pitchs, max_pitchs)\n return self.report\n\n def getMinMaxPitch(self, pm: pretty_midi.PrettyMIDI):\n \"\"\"\n find the min and max pitch inside a midi file\n \"\"\"\n notes = [\n note.pitch for instrument in pm.instruments for note in instrument.notes\n ]\n return min(notes), max(notes)\n\n def SaveFilterMIDIfiles(self):\n \"\"\"\n according generated meta data info to filter out those not in range\n \"\"\"\n report = self.generateMidiFileReport()\n temp_mean, temp_std, key, left_boundary, right_boundary = report.aggregation_report()\n piano_roll_paths = []\n for pm, path in zip(self.pms, self.paths):\n try:\n tempo = pm.estimate_tempo()\n min_pitch, max_pitch = self.getMinMaxPitch(pm)\n if self.isTempoInRange(tempo, temp_mean, temp_std) \\\n and self.isPitchInRange(min_pitch, max_pitch, left_boundary, right_boundary) \\\n and self.isKeyMatch(pm.key_signature_changes[0].key_number, key):\n savedPath = os.path.join(os.getcwd(), 'filterData')\n if not os.path.exists(savedPath):\n os.makedirs(savedPath, exist_ok=True)\n shutil.move(\n path, os.path.join(os.getcwd(), 'filterData', os.path.basename(path)))\n except:\n pass\n\n def isTempoInRange(self, tempo: float, mean: float, std: float) -> bool:\n \"\"\"\n a helper function that can be used check if a midi file's tempo in range\n \"\"\"\n if tempo > (mean - std) and tempo < (mean + std):\n return True\n return False\n\n def isKeyMatch(self, key: int, grand_truth_key: int) -> bool:\n if key == grand_truth_key:\n return True\n return False\n\n def isPitchInRange(self, low_pitch: int,\n high_pitch: int,\n left_boundary: int,\n right_boundary: int) -> bool:\n if low_pitch >= left_boundary and high_pitch <= right_boundary:\n return True\n return False\n\n def fileFilter(self):\n \"\"\"\n first filtering that only allow one tempo and one key inside a midi file\n \"\"\"\n self.pms: List[pretty_midi.PrettyMIDI] = []\n self.paths: List[str] = []\n for (dirPath, _, files) in walk(self.path): # type: ignore\n for file in files:\n # get the absoluted path of file\n path = join(dirPath, file)\n try:\n pm = pretty_midi.PrettyMIDI(path)\n # only handle files contain one key and one tempo\n if len(pm.key_signature_changes) == 1 \\\n and len(pm.time_signature_changes) == 1:\n self.pms.append(pm)\n self.paths.append(path)\n except: # skip all parsing exceptions\n pass\n\n\ndef cliArgParser(argv) -> Any:\n if len(argv) != 2:\n raise ValueError(f\"path of folder must be provided\")\n if isdir(argv[1]):\n path = os.path.abspath(argv[1])\n return path\n else:\n raise ValueError(f\"provided path is not a folder\")\n\n\nif __name__ == \"__main__\":\n try:\n path = cliArgParser(argv)\n p = Preprocess(path)\n p.SaveFilterMIDIfiles()\n except Exception as err:\n print(traceback.format_exc())\n exit(1)\n"
] | [
[
"numpy.array"
]
] |
kushalj001/transformers | [
"0538820737bd8fb9ba1eb3a772412c6bbe2433ab"
] | [
"src/transformers/modeling_t5.py"
] | [
"# coding=utf-8\n# Copyright 2018 Mesh TensorFlow authors, T5 Authors and HuggingFace Inc. 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\"\"\" PyTorch T5 model. \"\"\"\n\n\nimport copy\nimport math\nimport os\nimport warnings\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom torch.nn import CrossEntropyLoss\n\nfrom .configuration_t5 import T5Config\nfrom .file_utils import (\n DUMMY_INPUTS,\n DUMMY_MASK,\n add_start_docstrings,\n add_start_docstrings_to_model_forward,\n replace_return_docstrings,\n)\nfrom .modeling_outputs import BaseModelOutput, BaseModelOutputWithPast, Seq2SeqLMOutput, Seq2SeqModelOutput\nfrom .modeling_utils import PreTrainedModel, find_pruneable_heads_and_indices, prune_linear_layer\nfrom .utils import logging\n\n\nlogger = logging.get_logger(__name__)\n\n_CONFIG_FOR_DOC = \"T5Config\"\n_TOKENIZER_FOR_DOC = \"T5Tokenizer\"\n\n####################################################\n# This dict contains shortcut names and associated url\n# for the pretrained weights provided with the models\n####################################################\nT5_PRETRAINED_MODEL_ARCHIVE_LIST = [\n \"t5-small\",\n \"t5-base\",\n \"t5-large\",\n \"t5-3b\",\n \"t5-11b\",\n # See all T5 models at https://huggingface.co/models?filter=t5\n]\n\n\n####################################################\n# This is a conversion method from TF 1.0 to PyTorch\n# More details: https://medium.com/huggingface/from-tensorflow-to-pytorch-265f40ef2a28\n####################################################\ndef load_tf_weights_in_t5(model, config, tf_checkpoint_path):\n \"\"\"Load tf checkpoints in a pytorch model.\"\"\"\n try:\n import re\n\n import numpy as np\n import tensorflow as tf\n except ImportError:\n logger.error(\n \"Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see \"\n \"https://www.tensorflow.org/install/ for installation instructions.\"\n )\n raise\n tf_path = os.path.abspath(tf_checkpoint_path)\n logger.info(\"Converting TensorFlow checkpoint from {}\".format(tf_path))\n # Load weights from TF model\n init_vars = tf.train.list_variables(tf_path)\n names = []\n tf_weights = {}\n for name, shape in init_vars:\n logger.info(\"Loading TF weight {} with shape {}\".format(name, shape))\n array = tf.train.load_variable(tf_path, name)\n names.append(name)\n tf_weights[name] = array\n\n for txt_name in names:\n name = txt_name.split(\"/\")\n # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v\n # which are not required for using pretrained model\n if any(\n n in [\"adam_v\", \"adam_m\", \"AdamWeightDecayOptimizer\", \"AdamWeightDecayOptimizer_1\", \"global_step\"]\n for n in name\n ):\n logger.info(\"Skipping {}\".format(\"/\".join(name)))\n tf_weights.pop(txt_name, None)\n continue\n if \"_slot_\" in name[-1]:\n logger.info(\"Skipping {}\".format(\"/\".join(name)))\n tf_weights.pop(txt_name, None)\n continue\n pointer = model\n array = tf_weights[txt_name]\n for m_name in name:\n if re.fullmatch(r\"[A-Za-z]+_\\d+\", m_name):\n scope_names = re.split(r\"_(\\d+)\", m_name)\n else:\n scope_names = [m_name]\n if scope_names[0] in [\"kernel\", \"scale\", \"embedding\"]:\n pointer = getattr(pointer, \"weight\")\n # elif scope_names[0] == 'scale':\n # pointer = getattr(pointer, 'weight')\n # elif scope_names[0] == 'output_bias' or scope_names[0] == 'beta':\n # pointer = getattr(pointer, 'bias')\n # elif scope_names[0] == 'squad':\n # pointer = getattr(pointer, 'classifier')\n else:\n try:\n pointer = getattr(pointer, scope_names[0])\n except AttributeError:\n logger.info(\"Skipping {}\".format(\"/\".join(name)))\n continue\n if len(scope_names) >= 2:\n num = int(scope_names[1])\n pointer = pointer[num]\n if scope_names[0] not in [\"kernel\", \"scale\", \"embedding\"]:\n pointer = getattr(pointer, \"weight\")\n if scope_names[0] != \"embedding\":\n logger.info(\"Transposing numpy weight of shape {} for {}\".format(array.shape, name))\n array = np.transpose(array)\n try:\n assert (\n pointer.shape == array.shape\n ), f\"Pointer shape {pointer.shape} and array shape {array.shape} mismatched\"\n except AssertionError as e:\n e.args += (pointer.shape, array.shape)\n raise\n logger.info(\"Initialize PyTorch weight {}\".format(name))\n pointer.data = torch.from_numpy(array.astype(np.float32))\n tf_weights.pop(txt_name, None)\n\n logger.info(\"Weights not copied to PyTorch model: {}\".format(\", \".join(tf_weights.keys())))\n # logger.info(\"Weights not copied to PyTorch model: {}\".format(', '.join(tf_weights.keys())))\n return model\n\n\n####################################################\n# PyTorch Models are constructed by sub-classing\n# - torch.nn.Module for the layers and\n# - PreTrainedModel for the models (it-self a sub-class of torch.nn.Module)\n####################################################\n\n\nclass T5LayerNorm(nn.Module):\n def __init__(self, hidden_size, eps=1e-6):\n \"\"\"\n Construct a layernorm module in the T5 style No bias and no subtraction of mean.\n \"\"\"\n super().__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.variance_epsilon = eps\n\n def forward(self, x):\n # layer norm should always be calculated in float32\n variance = x.to(torch.float32).pow(2).mean(-1, keepdim=True)\n x = x / torch.sqrt(variance + self.variance_epsilon)\n\n if self.weight.dtype == torch.float16:\n x = x.to(torch.float16)\n return self.weight * x\n\n\nclass T5DenseReluDense(nn.Module):\n def __init__(self, config):\n super().__init__()\n self.wi = nn.Linear(config.d_model, config.d_ff, bias=False)\n self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)\n self.dropout = nn.Dropout(config.dropout_rate)\n\n def forward(self, hidden_states):\n h = self.wi(hidden_states)\n h = F.relu(h)\n h = self.dropout(h)\n h = self.wo(h)\n return h\n\n\nclass T5LayerFF(nn.Module):\n def __init__(self, config):\n super().__init__()\n self.DenseReluDense = T5DenseReluDense(config)\n self.layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)\n self.dropout = nn.Dropout(config.dropout_rate)\n\n def forward(self, hidden_states):\n norm_x = self.layer_norm(hidden_states)\n y = self.DenseReluDense(norm_x)\n layer_output = hidden_states + self.dropout(y)\n return layer_output\n\n\nclass T5Attention(nn.Module):\n def __init__(self, config: T5Config, has_relative_attention_bias=False, is_bidirectional=False):\n super().__init__()\n self.is_bidirectional = is_bidirectional\n self.is_decoder = config.is_decoder\n self.has_relative_attention_bias = has_relative_attention_bias\n\n self.relative_attention_num_buckets = config.relative_attention_num_buckets\n self.d_model = config.d_model\n self.d_kv = config.d_kv\n self.n_heads = config.num_heads\n self.dropout = config.dropout_rate\n self.inner_dim = self.n_heads * self.d_kv\n\n # Mesh TensorFlow initialization to avoid scaling before softmax\n self.q = nn.Linear(self.d_model, self.inner_dim, bias=False)\n self.k = nn.Linear(self.d_model, self.inner_dim, bias=False)\n self.v = nn.Linear(self.d_model, self.inner_dim, bias=False)\n self.o = nn.Linear(self.inner_dim, self.d_model, bias=False)\n\n if self.has_relative_attention_bias:\n self.relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets, self.n_heads)\n self.pruned_heads = set()\n\n def prune_heads(self, heads):\n if len(heads) == 0:\n return\n heads, index = find_pruneable_heads_and_indices(heads, self.n_heads, self.d_kv, self.pruned_heads)\n # Prune linear layers\n self.q = prune_linear_layer(self.q, index)\n self.k = prune_linear_layer(self.k, index)\n self.v = prune_linear_layer(self.v, index)\n self.o = prune_linear_layer(self.o, index, dim=1)\n # Update hyper params\n self.n_heads = self.n_heads - len(heads)\n self.inner_dim = self.d_kv * self.n_heads\n self.pruned_heads = self.pruned_heads.union(heads)\n\n @staticmethod\n def _relative_position_bucket(relative_position, bidirectional=True, num_buckets=32, max_distance=128):\n \"\"\"\n Adapted from Mesh Tensorflow:\n https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593\n\n Translate relative position to a bucket number for relative attention. The relative position is defined as\n memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to\n position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for\n small absolute relative_position and larger buckets for larger absolute relative_positions. All relative\n positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket.\n This should allow for more graceful generalization to longer sequences than the model has been trained on\n\n Args:\n relative_position: an int32 Tensor\n bidirectional: a boolean - whether the attention is bidirectional\n num_buckets: an integer\n max_distance: an integer\n\n Returns:\n a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets)\n \"\"\"\n ret = 0\n n = -relative_position\n if bidirectional:\n num_buckets //= 2\n ret += (n < 0).to(torch.long) * num_buckets # mtf.to_int32(mtf.less(n, 0)) * num_buckets\n n = torch.abs(n)\n else:\n n = torch.max(n, torch.zeros_like(n))\n # now n is in the range [0, inf)\n\n # half of the buckets are for exact increments in positions\n max_exact = num_buckets // 2\n is_small = n < max_exact\n\n # The other half of the buckets are for logarithmically bigger bins in positions up to max_distance\n val_if_large = max_exact + (\n torch.log(n.float() / max_exact) / math.log(max_distance / max_exact) * (num_buckets - max_exact)\n ).to(torch.long)\n val_if_large = torch.min(val_if_large, torch.full_like(val_if_large, num_buckets - 1))\n\n ret += torch.where(is_small, n, val_if_large)\n return ret\n\n def compute_bias(self, qlen, klen):\n \"\"\" Compute binned relative position bias \"\"\"\n context_position = torch.arange(qlen, dtype=torch.long)[:, None]\n memory_position = torch.arange(klen, dtype=torch.long)[None, :]\n relative_position = memory_position - context_position # shape (qlen, klen)\n rp_bucket = self._relative_position_bucket(\n relative_position, # shape (qlen, klen)\n bidirectional=self.is_bidirectional,\n num_buckets=self.relative_attention_num_buckets,\n )\n rp_bucket = rp_bucket.to(self.relative_attention_bias.weight.device)\n values = self.relative_attention_bias(rp_bucket) # shape (qlen, klen, num_heads)\n values = values.permute([2, 0, 1]).unsqueeze(0) # shape (1, num_heads, qlen, klen)\n return values\n\n def forward(\n self,\n input,\n mask=None,\n kv=None,\n position_bias=None,\n past_key_value=None,\n head_mask=None,\n query_length=None,\n use_cache=False,\n output_attentions=False,\n ):\n \"\"\"\n Self-attention (if kv is None) or attention over source sentence (provided by kv).\n \"\"\"\n # Input is (bs, qlen, dim)\n # Mask is (bs, klen) (non-causal) or (bs, klen, klen)\n # past_key_value[0] is (bs, n_heads, q_len - 1, dim_per_head)\n bs, qlen, dim = input.size()\n\n if past_key_value is not None:\n assert self.is_decoder is True, \"Encoder cannot cache past key value states\"\n assert (\n len(past_key_value) == 2\n ), \"past_key_value should have 2 past states: keys and values. Got {} past states\".format(\n len(past_key_value)\n )\n real_qlen = qlen + past_key_value[0].shape[2] if query_length is None else query_length\n else:\n real_qlen = qlen\n\n if kv is None:\n klen = real_qlen\n else:\n klen = kv.size(1)\n\n def shape(x):\n \"\"\" projection \"\"\"\n return x.view(bs, -1, self.n_heads, self.d_kv).transpose(1, 2)\n\n def unshape(x):\n \"\"\" compute context \"\"\"\n return x.transpose(1, 2).contiguous().view(bs, -1, self.inner_dim)\n\n q = shape(self.q(input)) # (bs, n_heads, qlen, dim_per_head)\n\n if kv is None:\n k = shape(self.k(input)) # (bs, n_heads, qlen, dim_per_head)\n v = shape(self.v(input)) # (bs, n_heads, qlen, dim_per_head)\n elif past_key_value is None:\n k = v = kv\n k = shape(self.k(k)) # (bs, n_heads, qlen, dim_per_head)\n v = shape(self.v(v)) # (bs, n_heads, qlen, dim_per_head)\n\n if past_key_value is not None:\n if kv is None:\n k_, v_ = past_key_value\n k = torch.cat([k_, k], dim=2) # (bs, n_heads, klen, dim_per_head)\n v = torch.cat([v_, v], dim=2) # (bs, n_heads, klen, dim_per_head)\n else:\n k, v = past_key_value\n\n if self.is_decoder and use_cache is True:\n present_key_value_state = ((k, v),)\n else:\n present_key_value_state = (None,)\n\n # (bs, n_heads, qlen, klen)\n scores = torch.matmul(\n q, k.transpose(3, 2)\n ) # equivalent of torch.einsum(\"bnqd,bnkd->bnqk\", q, k), compatible with onnx op>9\n\n if position_bias is None:\n if not self.has_relative_attention_bias:\n raise ValueError(\"No position_bias provided and no weights to compute position_bias\")\n position_bias = self.compute_bias(real_qlen, klen)\n\n # if key and values are already calculated\n # we want only the last query position bias\n if past_key_value is not None:\n position_bias = position_bias[:, :, -qlen:, :]\n\n if mask is not None:\n position_bias = position_bias + mask # (bs, n_heads, qlen, klen)\n\n scores += position_bias\n weights = F.softmax(scores.float(), dim=-1).type_as(scores) # (bs, n_heads, qlen, klen)\n weights = F.dropout(weights, p=self.dropout, training=self.training) # (bs, n_heads, qlen, klen)\n\n # Mask heads if we want to\n if head_mask is not None:\n weights = weights * head_mask\n\n context = torch.matmul(weights, v) # (bs, n_heads, qlen, dim_per_head)\n context = unshape(context) # (bs, qlen, dim)\n\n context = self.o(context)\n\n outputs = (context,) + present_key_value_state\n\n if output_attentions:\n outputs = outputs + (weights,)\n if self.has_relative_attention_bias:\n outputs = outputs + (position_bias,)\n return outputs\n\n\nclass T5LayerSelfAttention(nn.Module):\n def __init__(self, config, has_relative_attention_bias=False):\n super().__init__()\n self.SelfAttention = T5Attention(\n config, has_relative_attention_bias=has_relative_attention_bias, is_bidirectional=not config.is_decoder\n )\n self.layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)\n self.dropout = nn.Dropout(config.dropout_rate)\n\n def forward(\n self,\n hidden_states,\n attention_mask=None,\n position_bias=None,\n head_mask=None,\n past_key_value=None,\n use_cache=False,\n output_attentions=False,\n ):\n norm_x = self.layer_norm(hidden_states)\n attention_output = self.SelfAttention(\n norm_x,\n mask=attention_mask,\n position_bias=position_bias,\n head_mask=head_mask,\n past_key_value=past_key_value,\n use_cache=use_cache,\n output_attentions=output_attentions,\n )\n y = attention_output[0]\n layer_output = hidden_states + self.dropout(y)\n outputs = (layer_output,) + attention_output[1:] # add attentions if we output them\n return outputs\n\n\nclass T5LayerCrossAttention(nn.Module):\n def __init__(self, config, has_relative_attention_bias=False):\n super().__init__()\n self.EncDecAttention = T5Attention(\n config, has_relative_attention_bias=has_relative_attention_bias, is_bidirectional=True\n )\n self.layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)\n self.dropout = nn.Dropout(config.dropout_rate)\n\n def forward(\n self,\n hidden_states,\n kv,\n attention_mask=None,\n position_bias=None,\n head_mask=None,\n past_key_value=None,\n use_cache=False,\n query_length=None,\n output_attentions=False,\n ):\n norm_x = self.layer_norm(hidden_states)\n attention_output = self.EncDecAttention(\n norm_x,\n mask=attention_mask,\n kv=kv,\n position_bias=position_bias,\n head_mask=head_mask,\n past_key_value=past_key_value,\n use_cache=use_cache,\n query_length=query_length,\n output_attentions=output_attentions,\n )\n y = attention_output[0]\n layer_output = hidden_states + self.dropout(y)\n outputs = (layer_output,) + attention_output[1:] # add attentions if we output them\n return outputs\n\n\nclass T5Block(nn.Module):\n def __init__(self, config, has_relative_attention_bias=False):\n super().__init__()\n self.is_decoder = config.is_decoder\n self.layer = nn.ModuleList()\n self.layer.append(T5LayerSelfAttention(config, has_relative_attention_bias=has_relative_attention_bias))\n if self.is_decoder:\n self.layer.append(T5LayerCrossAttention(config, has_relative_attention_bias=has_relative_attention_bias))\n\n self.layer.append(T5LayerFF(config))\n\n def forward(\n self,\n hidden_states,\n attention_mask=None,\n position_bias=None,\n encoder_hidden_states=None,\n encoder_attention_mask=None,\n encoder_decoder_position_bias=None,\n head_mask=None,\n past_key_value=None,\n use_cache=False,\n output_attentions=False,\n ):\n\n if past_key_value is not None:\n assert self.is_decoder, \"Only decoder can use `past_key_values`\"\n expected_num_past_key_values = 2 if encoder_hidden_states is None else 4\n\n error_message = \"There should be {} past states. 2 (past / key) for self attention.{} Got {} past key / value states\".format(\n expected_num_past_key_values,\n \"2 (past / key) for cross attention\" if expected_num_past_key_values == 4 else \"\",\n len(past_key_value),\n )\n assert len(past_key_value) == expected_num_past_key_values, error_message\n\n self_attn_past_key_value = past_key_value[:2]\n cross_attn_past_key_value = past_key_value[2:]\n else:\n self_attn_past_key_value, cross_attn_past_key_value = None, None\n\n self_attention_outputs = self.layer[0](\n hidden_states,\n attention_mask=attention_mask,\n position_bias=position_bias,\n head_mask=head_mask,\n past_key_value=self_attn_past_key_value,\n use_cache=use_cache,\n output_attentions=output_attentions,\n )\n hidden_states, present_key_value_state = self_attention_outputs[:2]\n attention_outputs = self_attention_outputs[2:] # Keep self-attention outputs and relative position weights\n\n if self.is_decoder and encoder_hidden_states is not None:\n # the actual query length is unknown for cross attention\n # if using past key value states. Need to inject it here\n if present_key_value_state is not None:\n query_length = present_key_value_state[0].shape[2]\n else:\n query_length = None\n\n cross_attention_outputs = self.layer[1](\n hidden_states,\n kv=encoder_hidden_states,\n attention_mask=encoder_attention_mask,\n position_bias=encoder_decoder_position_bias,\n head_mask=head_mask,\n past_key_value=cross_attn_past_key_value,\n query_length=query_length,\n use_cache=use_cache,\n output_attentions=output_attentions,\n )\n hidden_states = cross_attention_outputs[0]\n # Combine self attn and cross attn key value states\n if present_key_value_state is not None:\n present_key_value_state = present_key_value_state + cross_attention_outputs[1]\n\n # Keep cross-attention outputs and relative position weights\n attention_outputs = attention_outputs + cross_attention_outputs[2:]\n\n # Apply Feed Forward layer\n hidden_states = self.layer[-1](hidden_states)\n outputs = (hidden_states,)\n\n # Add attentions if we output them\n outputs = outputs + (present_key_value_state,) + attention_outputs\n return outputs # hidden-states, present_key_value_states, (self-attention weights), (self-attention position bias), (cross-attention weights), (cross-attention position bias)\n\n\nclass T5PreTrainedModel(PreTrainedModel):\n \"\"\"\n An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained\n models.\n \"\"\"\n\n config_class = T5Config\n load_tf_weights = load_tf_weights_in_t5\n base_model_prefix = \"transformer\"\n\n @property\n def dummy_inputs(self):\n input_ids = torch.tensor(DUMMY_INPUTS)\n input_mask = torch.tensor(DUMMY_MASK)\n dummy_inputs = {\n \"decoder_input_ids\": input_ids,\n \"input_ids\": input_ids,\n \"decoder_attention_mask\": input_mask,\n }\n return dummy_inputs\n\n def _init_weights(self, module):\n \"\"\" Initialize the weights \"\"\"\n factor = self.config.initializer_factor # Used for testing weights initialization\n if isinstance(module, T5LayerNorm):\n module.weight.data.fill_(factor * 1.0)\n elif isinstance(module, (T5Model, T5ForConditionalGeneration)):\n # Mesh TensorFlow embeddings initialization\n # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L1624\n module.shared.weight.data.normal_(mean=0.0, std=factor * 1.0)\n elif isinstance(module, T5DenseReluDense):\n # Mesh TensorFlow FF initialization\n # See https://github.com/tensorflow/mesh/blob/master/mesh_tensorflow/transformer/transformer_layers.py#L56\n # and https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L89\n module.wi.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_model) ** -0.5))\n if hasattr(module.wi, \"bias\") and module.wi.bias is not None:\n module.wi.bias.data.zero_()\n module.wo.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))\n if hasattr(module.wo, \"bias\") and module.wo.bias is not None:\n module.wo.bias.data.zero_()\n elif isinstance(module, T5Attention):\n # Mesh TensorFlow attention initialization to avoid scaling before softmax\n # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/attention.py#L136\n d_model = self.config.d_model\n d_kv = self.config.d_kv\n n_heads = self.config.num_heads\n module.q.weight.data.normal_(mean=0.0, std=factor * ((d_model * d_kv) ** -0.5))\n module.k.weight.data.normal_(mean=0.0, std=factor * (d_model ** -0.5))\n module.v.weight.data.normal_(mean=0.0, std=factor * (d_model ** -0.5))\n module.o.weight.data.normal_(mean=0.0, std=factor * ((n_heads * d_kv) ** -0.5))\n if module.has_relative_attention_bias:\n module.relative_attention_bias.weight.data.normal_(mean=0.0, std=factor * ((d_model) ** -0.5))\n\n def _shift_right(self, input_ids):\n decoder_start_token_id = self.config.decoder_start_token_id\n pad_token_id = self.config.pad_token_id\n\n assert (\n decoder_start_token_id is not None\n ), \"self.model.config.decoder_start_token_id has to be defined. In T5 it is usually set to the pad_token_id. See T5 docs for more information\"\n\n # shift inputs to the right\n shifted_input_ids = input_ids.new_zeros(input_ids.shape)\n shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()\n shifted_input_ids[..., 0] = decoder_start_token_id\n\n assert pad_token_id is not None, \"self.model.config.pad_token_id has to be defined.\"\n # replace possible -100 values in labels by `pad_token_id`\n shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)\n\n assert torch.all(shifted_input_ids >= 0).item(), \"Verify that `shifted_input_ids` has only positive values\"\n\n return shifted_input_ids\n\n\nclass T5Stack(T5PreTrainedModel):\n def __init__(self, config, embed_tokens=None):\n super().__init__(config)\n\n self.embed_tokens = embed_tokens\n self.is_decoder = config.is_decoder\n\n self.block = nn.ModuleList(\n [T5Block(config, has_relative_attention_bias=bool(i == 0)) for i in range(config.num_layers)]\n )\n self.final_layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)\n self.dropout = nn.Dropout(config.dropout_rate)\n\n self.init_weights()\n\n def get_input_embeddings(self):\n return self.embed_tokens\n\n def get_output_embeddings(self):\n return self.embed_tokens\n\n def set_input_embeddings(self, new_embeddings):\n self.embed_tokens = new_embeddings\n\n def forward(\n self,\n input_ids=None,\n attention_mask=None,\n encoder_hidden_states=None,\n encoder_attention_mask=None,\n inputs_embeds=None,\n head_mask=None,\n past_key_values=None,\n use_cache=None,\n output_attentions=None,\n output_hidden_states=None,\n return_dict=None,\n ):\n\n use_cache = use_cache if use_cache is not None else self.config.use_cache\n output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions\n output_hidden_states = (\n output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states\n )\n return_dict = return_dict if return_dict is not None else self.config.use_return_dict\n\n if input_ids is not None and inputs_embeds is not None:\n err_msg_prefix = \"decoder_\" if self.is_decoder else \"\"\n raise ValueError(\n f\"You cannot specify both {err_msg_prefix}inputs and {err_msg_prefix}inputs_embeds at the same time\"\n )\n elif input_ids is not None:\n input_shape = input_ids.size()\n input_ids = input_ids.view(-1, input_shape[-1])\n elif inputs_embeds is not None:\n input_shape = inputs_embeds.size()[:-1]\n else:\n err_msg_prefix = \"decoder_\" if self.is_decoder else \"\"\n raise ValueError(f\"You have to specify either {err_msg_prefix}inputs or {err_msg_prefix}inputs_embeds\")\n\n if inputs_embeds is None:\n assert self.embed_tokens is not None, \"You have to initialize the model with valid token embeddings\"\n inputs_embeds = self.embed_tokens(input_ids)\n\n batch_size, seq_length = input_shape\n\n # required mask seq length can be calculated via length of past\n mask_seq_length = past_key_values[0][0].shape[2] + seq_length if past_key_values is not None else seq_length\n\n if use_cache is True:\n assert self.is_decoder, \":obj:`use_cache` can only be set to `True` if {} is used as a decoder\".format(\n self\n )\n\n if attention_mask is None:\n attention_mask = torch.ones(batch_size, mask_seq_length).to(inputs_embeds.device)\n if self.is_decoder and encoder_attention_mask is None and encoder_hidden_states is not None:\n encoder_seq_length = encoder_hidden_states.shape[1]\n encoder_attention_mask = torch.ones(\n batch_size, encoder_seq_length, device=inputs_embeds.device, dtype=torch.long\n )\n\n # initialize past_key_values with `None` if past does not exist\n if past_key_values is None:\n past_key_values = [None] * len(self.block)\n\n # ourselves in which case we just need to make it broadcastable to all heads.\n extended_attention_mask = self.get_extended_attention_mask(attention_mask, input_shape, inputs_embeds.device)\n\n if self.is_decoder and encoder_attention_mask is not None:\n encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)\n else:\n encoder_extended_attention_mask = None\n\n # Prepare head mask if needed\n head_mask = self.get_head_mask(head_mask, self.config.num_layers)\n present_key_value_states = () if use_cache else None\n all_hidden_states = () if output_hidden_states else None\n all_attentions = () if output_attentions else None\n position_bias = None\n encoder_decoder_position_bias = None\n\n hidden_states = self.dropout(inputs_embeds)\n\n for i, (layer_module, past_key_value) in enumerate(zip(self.block, past_key_values)):\n if output_hidden_states:\n all_hidden_states = all_hidden_states + (hidden_states,)\n\n layer_outputs = layer_module(\n hidden_states,\n attention_mask=extended_attention_mask,\n position_bias=position_bias,\n encoder_hidden_states=encoder_hidden_states,\n encoder_attention_mask=encoder_extended_attention_mask,\n encoder_decoder_position_bias=encoder_decoder_position_bias,\n head_mask=head_mask[i],\n past_key_value=past_key_value,\n use_cache=use_cache,\n output_attentions=output_attentions,\n )\n # layer_outputs is a tuple with:\n # hidden-states, key-value-states, (self-attention weights), (self-attention position bias), (cross-attention weights), (cross-attention position bias)\n hidden_states, present_key_value_state = layer_outputs[:2]\n\n if i == 0:\n # We share the position biases between the layers - the first layer store them\n # layer_outputs = hidden-states, key-value-states (self-attention weights), (self-attention position bias), (cross-attention weights), (cross-attention position bias)\n position_bias = layer_outputs[3 if output_attentions else 2]\n if self.is_decoder and encoder_hidden_states is not None:\n encoder_decoder_position_bias = layer_outputs[5 if output_attentions else 3]\n # append next layer key value states\n if use_cache:\n present_key_value_states = present_key_value_states + (present_key_value_state,)\n\n if output_attentions:\n all_attentions = all_attentions + (layer_outputs[2],) # We keep only self-attention weights for now\n\n hidden_states = self.final_layer_norm(hidden_states)\n hidden_states = self.dropout(hidden_states)\n\n # Add last layer\n if output_hidden_states:\n all_hidden_states = all_hidden_states + (hidden_states,)\n\n if not return_dict:\n return tuple(\n v\n for v in [hidden_states, present_key_value_states, all_hidden_states, all_attentions]\n if v is not None\n )\n return BaseModelOutputWithPast(\n last_hidden_state=hidden_states,\n past_key_values=present_key_value_states,\n hidden_states=all_hidden_states,\n attentions=all_attentions,\n )\n\n\nT5_START_DOCSTRING = r\"\"\"\n\n The T5 model was proposed in `Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer\n <https://arxiv.org/abs/1910.10683>`__ by Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang,\n Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu. It's an encoder decoder transformer pre-trained in a text-to-text\n denoising generative setting.\n\n This model inherits from :class:`~transformers.PreTrainedModel`. Check the superclass documentation for the generic\n methods the library implements for all its model (such as downloading or saving, resizing the input embeddings,\n pruning heads etc.)\n\n This model is also a PyTorch `torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>`__\n subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to\n general usage and behavior.\n\n Parameters:\n config (:class:`~transformers.T5Config`): Model configuration class with all the parameters of the model.\n Initializing with a config file does not load the weights associated with the model, only the\n configuration. Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model\n weights.\n\"\"\"\n\nT5_INPUTS_DOCSTRING = r\"\"\"\n Args:\n input_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`):\n Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you\n should be able to pad the inputs on both the right and the left.\n\n Indices can be obtained using :class:`~transformers.T5Tokenizer`. See\n :meth:`transformers.PreTrainedTokenizer.encode` and :meth:`transformers.PreTrainedTokenizer.__call__` for\n detail.\n\n To know more on how to prepare :obj:`input_ids` for pretraining take a look a `T5 Training\n <./t5.html#training>`__.\n attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):\n Mask to avoid performing attention on padding token indices. Mask values selected in ``[0, 1]``:\n\n - 1 for tokens that are **not masked**,\n - 0 for tokens that are **masked**.\n\n `What are attention masks? <../glossary.html#attention-mask>`__\n decoder_input_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, target_sequence_length)`, `optional`):\n Provide for sequence to sequence training. T5 uses the :obj:`pad_token_id` as the starting token for\n :obj:`decoder_input_ids` generation. If :obj:`past_key_values` is used, optionally only the last\n :obj:`decoder_input_ids` have to be input (see :obj:`past_key_values`).\n\n To know more on how to prepare :obj:`decoder_input_ids` for pretraining take a look at `T5 Training\n <./t5.html#training>`__. If :obj:`decoder_input_ids` and :obj:`decoder_inputs_embeds` are both unset,\n :obj:`decoder_input_ids` takes the value of :obj:`input_ids`.\n decoder_attention_mask (:obj:`torch.BoolTensor` of shape :obj:`(batch_size, tgt_seq_len)`, `optional`):\n Default behavior: generate a tensor that ignores pad tokens in :obj:`decoder_input_ids`. Causal mask will\n also be used by default.\n encoder_outputs (:obj:`tuple(tuple(torch.FloatTensor)`, `optional`):\n Tuple consists of (:obj:`last_hidden_state`, :obj:`optional`: `hidden_states`, :obj:`optional`:\n `attentions`) :obj:`last_hidden_state` of shape :obj:`(batch_size, sequence_length, hidden_size)` is a\n sequence of hidden states at the output of the last layer of the encoder. Used in the cross-attention of\n the decoder.\n past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):\n Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.\n\n If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`\n (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`\n instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.\n head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`):\n Mask to nullify selected heads of the self-attention modules. Mask values selected in ``[0, 1]``:\n\n - 1 indicates the head is **not masked**,\n - 0 indicates the head is **masked**.\n\n inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):\n Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.\n This is useful if you want more control over how to convert :obj:`input_ids` indices into associated\n vectors than the model's internal embedding lookup matrix.\n decoder_inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, target_sequence_length, hidden_size)`, `optional`):\n Optionally, instead of passing :obj:`decoder_input_ids` you can choose to directly pass an embedded\n representation. If :obj:`past_key_values` is used, optionally only the last :obj:`decoder_inputs_embeds`\n have to be input (see :obj:`past_key_values`). This is useful if you want more control over how to convert\n :obj:`decoder_input_ids` indices into associated vectors than the model's internal embedding lookup matrix.\n\n If :obj:`decoder_input_ids` and :obj:`decoder_inputs_embeds` are both unset, :obj:`decoder_inputs_embeds`\n takes the value of :obj:`inputs_embeds`.\n\n use_cache (:obj:`bool`, `optional`):\n If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up\n decoding (see :obj:`past_key_values`).\n\n output_attentions (:obj:`bool`, `optional`):\n Whether or not to return the attentions tensors of all attention layers. See ``attentions`` under returned\n tensors for more detail.\n output_hidden_states (:obj:`bool`, `optional`):\n Whether or not to return the hidden states of all layers. See ``hidden_states`` under returned tensors for\n more detail.\n return_dict (:obj:`bool`, `optional`):\n Whether or not to return a :class:`~transformers.file_utils.ModelOutput` instead of a plain tuple.\n\"\"\"\n\n\n@add_start_docstrings(\n \"The bare T5 Model transformer outputting raw hidden-states\" \"without any specific head on top.\",\n T5_START_DOCSTRING,\n)\nclass T5Model(T5PreTrainedModel):\n def __init__(self, config: T5Config):\n super().__init__(config)\n self.shared = nn.Embedding(config.vocab_size, config.d_model)\n\n encoder_config = copy.deepcopy(config)\n encoder_config.use_cache = False\n encoder_config.is_encoder_decoder = False\n self.encoder = T5Stack(encoder_config, self.shared)\n\n decoder_config = copy.deepcopy(config)\n decoder_config.is_decoder = True\n decoder_config.is_encoder_decoder = False\n decoder_config.num_layers = config.num_decoder_layers\n self.decoder = T5Stack(decoder_config, self.shared)\n\n self.init_weights()\n\n def get_input_embeddings(self):\n return self.shared\n\n def set_input_embeddings(self, new_embeddings):\n self.shared = new_embeddings\n self.encoder.set_input_embeddings(new_embeddings)\n self.decoder.set_input_embeddings(new_embeddings)\n\n def get_encoder(self):\n return self.encoder\n\n def get_decoder(self):\n return self.decoder\n\n def _prune_heads(self, heads_to_prune):\n \"\"\"\n Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base\n class PreTrainedModel\n \"\"\"\n for layer, heads in heads_to_prune.items():\n self.encoder.layer[layer].attention.prune_heads(heads)\n\n @add_start_docstrings_to_model_forward(T5_INPUTS_DOCSTRING)\n @replace_return_docstrings(output_type=Seq2SeqModelOutput, config_class=_CONFIG_FOR_DOC)\n def forward(\n self,\n input_ids=None,\n attention_mask=None,\n decoder_input_ids=None,\n decoder_attention_mask=None,\n encoder_outputs=None,\n past_key_values=None,\n head_mask=None,\n inputs_embeds=None,\n decoder_inputs_embeds=None,\n use_cache=None,\n output_attentions=None,\n output_hidden_states=None,\n return_dict=None,\n **kwargs,\n ):\n r\"\"\"\n Returns:\n\n Example::\n\n >>> from transformers import T5Tokenizer, T5Model\n\n >>> tokenizer = T5Tokenizer.from_pretrained('t5-small')\n >>> model = T5Model.from_pretrained('t5-small')\n\n >>> input_ids = tokenizer(\"Studies have been shown that owning a dog is good for you\", return_tensors=\"pt\").input_ids # Batch size 1\n >>> decoder_input_ids = tokenizer(\"Studies show that\", return_tensors=\"pt\").input_ids # Batch size 1\n >>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids, return_dict=True)\n\n >>> last_hidden_states = outputs.last_hidden_state\n \"\"\"\n if \"decoder_past_key_value_states\" in kwargs:\n warnings.warn(\n \"The `decoder_past_key_value_states` argument is deprecated and will be removed in a future version, use `past_key_values` instead.\",\n FutureWarning,\n )\n past_key_values = kwargs.pop(\"decoder_past_key_value_states\")\n if \"decoder_past_key_values\" in kwargs:\n warnings.warn(\n \"The `decoder_past_key_values` argument is deprecated and will be removed in a future version, use `past_key_values` instead.\",\n FutureWarning,\n )\n past_key_values = kwargs.pop(\"decoder_past_key_values\")\n assert kwargs == {}, f\"Unexpected keyword arguments: {list(kwargs.keys())}.\"\n\n use_cache = use_cache if use_cache is not None else self.config.use_cache\n return_dict = return_dict if return_dict is not None else self.config.use_return_dict\n\n # Encode if needed (training, first prediction pass)\n if encoder_outputs is None:\n encoder_outputs = self.encoder(\n input_ids=input_ids,\n attention_mask=attention_mask,\n inputs_embeds=inputs_embeds,\n head_mask=head_mask,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n return_dict=return_dict,\n )\n elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):\n encoder_outputs = BaseModelOutput(\n last_hidden_state=encoder_outputs[0],\n hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,\n attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,\n )\n\n hidden_states = encoder_outputs[0]\n\n # Decode\n decoder_outputs = self.decoder(\n input_ids=decoder_input_ids,\n attention_mask=decoder_attention_mask,\n inputs_embeds=decoder_inputs_embeds,\n past_key_values=past_key_values,\n encoder_hidden_states=hidden_states,\n encoder_attention_mask=attention_mask,\n head_mask=head_mask,\n use_cache=use_cache,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n return_dict=return_dict,\n )\n\n if not return_dict:\n return decoder_outputs + encoder_outputs\n\n return Seq2SeqModelOutput(\n last_hidden_state=decoder_outputs.last_hidden_state,\n past_key_values=decoder_outputs.past_key_values,\n decoder_hidden_states=decoder_outputs.hidden_states,\n decoder_attentions=decoder_outputs.attentions,\n encoder_last_hidden_state=encoder_outputs.last_hidden_state,\n encoder_hidden_states=encoder_outputs.hidden_states,\n encoder_attentions=encoder_outputs.attentions,\n )\n\n\n@add_start_docstrings(\"\"\"T5 Model with a `language modeling` head on top. \"\"\", T5_START_DOCSTRING)\nclass T5ForConditionalGeneration(T5PreTrainedModel):\n authorized_missing_keys = [r\"encoder\\.embed_tokens\\.weight\", r\"decoder\\.embed_tokens\\.weight\", r\"lm_head\\.weight\"]\n\n def __init__(self, config):\n super().__init__(config)\n self.model_dim = config.d_model\n\n self.shared = nn.Embedding(config.vocab_size, config.d_model)\n\n encoder_config = copy.deepcopy(config)\n encoder_config.use_cache = False\n encoder_config.is_encoder_decoder = False\n self.encoder = T5Stack(encoder_config, self.shared)\n\n decoder_config = copy.deepcopy(config)\n decoder_config.is_decoder = True\n decoder_config.is_encoder_decoder = False\n decoder_config.num_layers = config.num_decoder_layers\n self.decoder = T5Stack(decoder_config, self.shared)\n\n self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)\n\n self.init_weights()\n\n def get_input_embeddings(self):\n return self.shared\n\n def set_input_embeddings(self, new_embeddings):\n self.shared = new_embeddings\n self.encoder.set_input_embeddings(new_embeddings)\n self.decoder.set_input_embeddings(new_embeddings)\n\n def get_output_embeddings(self):\n return self.lm_head\n\n def get_encoder(self):\n return self.encoder\n\n def get_decoder(self):\n return self.decoder\n\n @add_start_docstrings_to_model_forward(T5_INPUTS_DOCSTRING)\n @replace_return_docstrings(output_type=Seq2SeqLMOutput, config_class=_CONFIG_FOR_DOC)\n def forward(\n self,\n input_ids=None,\n attention_mask=None,\n decoder_input_ids=None,\n decoder_attention_mask=None,\n encoder_outputs=None,\n past_key_values=None,\n head_mask=None,\n inputs_embeds=None,\n decoder_inputs_embeds=None,\n labels=None,\n use_cache=None,\n output_attentions=None,\n output_hidden_states=None,\n return_dict=None,\n **kwargs,\n ):\n r\"\"\"\n labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):\n Labels for computing the sequence classification/regression loss. Indices should be in :obj:`[-100, 0, ...,\n config.vocab_size - 1]`. All labels set to ``-100`` are ignored (masked), the loss is only computed for\n labels in ``[0, ..., config.vocab_size]``\n kwargs (:obj:`Dict[str, any]`, optional, defaults to `{}`):\n Used to hide legacy arguments that have been deprecated.\n\n Returns:\n\n Examples::\n\n >>> from transformers import T5Tokenizer, T5ForConditionalGeneration\n\n >>> tokenizer = T5Tokenizer.from_pretrained('t5-small')\n >>> model = T5ForConditionalGeneration.from_pretrained('t5-small', return_dict=True)\n\n >>> input_ids = tokenizer('The <extra_id_0> walks in <extra_id_1> park', return_tensors='pt').input_ids\n labels = tokenizer('<extra_id_0> cute dog <extra_id_1> the <extra_id_2> </s>', return_tensors='pt').input_ids\n >>> outputs = model(input_ids=input_ids, labels=labels)\n >>> loss = outputs.loss\n >>> logits = outputs.logits\n\n >>> input_ids = tokenizer(\"summarize: studies have shown that owning a dog is good for you \", return_tensors=\"pt\").input_ids # Batch size 1\n >>> outputs = model.generate(input_ids)\n \"\"\"\n\n if \"lm_labels\" in kwargs:\n warnings.warn(\n \"The `lm_labels` argument is deprecated and will be removed in a future version, use `labels` instead.\",\n FutureWarning,\n )\n labels = kwargs.pop(\"lm_labels\")\n if \"decoder_past_key_value_states\" in kwargs:\n warnings.warn(\n \"The `decoder_past_key_value_states` argument is deprecated and will be removed in a future version, use `past_key_values` instead.\",\n FutureWarning,\n )\n past_key_values = kwargs.pop(\"decoder_past_key_value_states\")\n if \"decoder_past_key_values\" in kwargs:\n warnings.warn(\n \"The `decoder_past_key_values` argument is deprecated and will be removed in a future version, use `past_key_values` instead.\",\n FutureWarning,\n )\n past_key_values = kwargs.pop(\"decoder_past_key_values\")\n assert kwargs == {}, f\"Unexpected keyword arguments: {list(kwargs.keys())}.\"\n\n use_cache = use_cache if use_cache is not None else self.config.use_cache\n return_dict = return_dict if return_dict is not None else self.config.use_return_dict\n\n # Encode if needed (training, first prediction pass)\n if encoder_outputs is None:\n # Convert encoder inputs in embeddings if needed\n encoder_outputs = self.encoder(\n input_ids=input_ids,\n attention_mask=attention_mask,\n inputs_embeds=inputs_embeds,\n head_mask=head_mask,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n return_dict=return_dict,\n )\n elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):\n encoder_outputs = BaseModelOutput(\n last_hidden_state=encoder_outputs[0],\n hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,\n attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,\n )\n\n hidden_states = encoder_outputs[0]\n\n if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:\n # get decoder inputs from shifting lm labels to the right\n decoder_input_ids = self._shift_right(labels)\n\n # If decoding with past key value states, only the last tokens\n # should be given as an input\n if past_key_values is not None:\n assert labels is None, \"Decoder should not use cached key value states when training.\"\n if decoder_input_ids is not None:\n decoder_input_ids = decoder_input_ids[:, -1:]\n if decoder_inputs_embeds is not None:\n decoder_inputs_embeds = decoder_inputs_embeds[:, -1:]\n\n # Decode\n decoder_outputs = self.decoder(\n input_ids=decoder_input_ids,\n attention_mask=decoder_attention_mask,\n inputs_embeds=decoder_inputs_embeds,\n past_key_values=past_key_values,\n encoder_hidden_states=hidden_states,\n encoder_attention_mask=attention_mask,\n head_mask=head_mask,\n use_cache=use_cache,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n return_dict=return_dict,\n )\n\n sequence_output = decoder_outputs[0]\n # Rescale output before projecting on vocab\n # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/transformer.py#L586\n sequence_output = sequence_output * (self.model_dim ** -0.5)\n lm_logits = self.lm_head(sequence_output)\n\n loss = None\n if labels is not None:\n loss_fct = CrossEntropyLoss(ignore_index=-100)\n loss = loss_fct(lm_logits.view(-1, lm_logits.size(-1)), labels.view(-1))\n # TODO(thom): Add z_loss https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L666\n\n if not return_dict:\n output = (lm_logits,) + decoder_outputs[1:] + encoder_outputs\n return ((loss,) + output) if loss is not None else output\n\n return Seq2SeqLMOutput(\n loss=loss,\n logits=lm_logits,\n past_key_values=decoder_outputs.past_key_values,\n decoder_hidden_states=decoder_outputs.hidden_states,\n decoder_attentions=decoder_outputs.attentions,\n encoder_last_hidden_state=encoder_outputs.last_hidden_state,\n encoder_hidden_states=encoder_outputs.hidden_states,\n encoder_attentions=encoder_outputs.attentions,\n )\n\n def prepare_inputs_for_generation(self, input_ids, past, attention_mask, use_cache, encoder_outputs, **kwargs):\n\n # cut decoder_input_ids if past is used\n if past is not None:\n input_ids = input_ids[:, -1:]\n\n return {\n \"decoder_input_ids\": input_ids,\n \"past_key_values\": past,\n \"encoder_outputs\": encoder_outputs,\n \"attention_mask\": attention_mask,\n \"use_cache\": use_cache,\n }\n\n def _reorder_cache(self, past, beam_idx):\n # if decoder past is not included in output\n # speedy decoding is disabled and no need to reorder\n if past is None:\n logger.warning(\"You might want to consider setting `use_cache=True` to speed up decoding\")\n return past\n\n reordered_decoder_past = ()\n for layer_past_states in past:\n # get the correct batch idx from layer past batch dim\n # batch dim of `past` is at 2nd position\n reordered_layer_past_states = ()\n for layer_past_state in layer_past_states:\n # need to set correct `past` for each of the four key / value states\n reordered_layer_past_states = reordered_layer_past_states + (\n layer_past_state.index_select(0, beam_idx),\n )\n\n assert reordered_layer_past_states[0].shape == layer_past_states[0].shape\n assert len(reordered_layer_past_states) == len(layer_past_states)\n\n reordered_decoder_past = reordered_decoder_past + (reordered_layer_past_states,)\n return reordered_decoder_past\n"
] | [
[
"torch.nn.Linear",
"torch.cat",
"torch.nn.ModuleList",
"torch.ones",
"torch.nn.CrossEntropyLoss",
"torch.where",
"torch.sqrt",
"tensorflow.train.list_variables",
"torch.abs",
"torch.tensor",
"numpy.transpose",
"torch.zeros_like",
"torch.nn.functional.relu",
"tensorflow.train.load_variable",
"torch.nn.functional.dropout",
"torch.full_like",
"torch.matmul",
"torch.nn.Dropout",
"torch.arange",
"torch.all",
"torch.nn.Embedding"
]
] |
sepam/machine-learning-engineering-for-production-public | [
"cd6053459eee9b7f30bf86da63104b3f1381383a"
] | [
"course4/week3-ungraded-labs/C4_W3_Lab_4_Github_Actions/app/main.py"
] | [
"import pickle\nimport numpy as np\nfrom typing import List\nfrom fastapi import FastAPI\nfrom pydantic import BaseModel, conlist\n\n\n\napp = FastAPI(title=\"Predicting Wine Class with batching\")\n\n# Open classifier in global scope\nwith open(\"models/wine-95-fixed.pkl\", \"rb\") as file:\n clf = pickle.load(file)\n\n\nclass Wine(BaseModel):\n batches: List[conlist(item_type=float, min_items=13, max_items=13)]\n\n\n# make predictions on this endpoint\[email protected](\"/predict\")\ndef predict(wine: Wine):\n batches = wine.batches\n np_batches = np.array(batches)\n pred = clf.predict(np_batches).tolist()\n return {\"Prediction\": pred}\n"
] | [
[
"numpy.array"
]
] |
GLaDO8/pytorch_playground | [
"3623de18881a37ce413c92d8a63ea9ba1cc401a5"
] | [
"nnwordembed.py"
] | [
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\n\ntorch.manual_seed(1)\n\nword_to_ix = {\"hello\": 0, \"world\": 1}\n#first argument is the size of the embedded matrix. The second argument is the dimension of each word embedding. \nembeds = nn.Embedding(2, 5) # 2 words in vocab, 5 dimensional embeddings\nlookup_tensor = torch.tensor([word_to_ix[\"hello\"], word_to_ix[\"world\"]], dtype=torch.long)\nhello_embed = embeds(lookup_tensor)\nprint(hello_embed)"
] | [
[
"torch.manual_seed",
"torch.tensor",
"torch.nn.Embedding"
]
] |
zactodd/mmdetection | [
"68532eb6f4643ddf0179a4384c8c9e004a2c1d07",
"84fbb2c6ee7346ea722cea3a4fa16d73e11fcafd"
] | [
"mmdet/models/dense_heads/pisa_retinanet_head.py",
"mmdet/models/dense_heads/ssd_head.py"
] | [
"import torch\n\nfrom mmdet.core import force_fp32, images_to_levels\nfrom ..builder import HEADS\nfrom ..losses import carl_loss, isr_p\nfrom .retina_head import RetinaHead\n\n\[email protected]_module()\nclass PISARetinaHead(RetinaHead):\n \"\"\"PISA Retinanet Head.\n\n The head owns the same structure with Retinanet Head, but differs in two\n aspects:\n 1. Importance-based Sample Reweighting Positive (ISR-P) is applied to\n change the positive loss weights.\n 2. Classification-aware regression loss is adopted as a third loss.\n \"\"\"\n\n @force_fp32(apply_to=('cls_scores', 'bbox_preds'))\n def loss(self,\n cls_scores,\n bbox_preds,\n gt_bboxes,\n gt_labels,\n img_metas,\n gt_bboxes_ignore=None):\n \"\"\"Compute losses of the head.\n\n Args:\n cls_scores (list[Tensor]): Box scores for each scale level\n Has shape (N, num_anchors * num_classes, H, W)\n bbox_preds (list[Tensor]): Box energies / deltas for each scale\n level with shape (N, num_anchors * 4, H, W)\n gt_bboxes (list[Tensor]): Ground truth bboxes of each image\n with shape (num_obj, 4).\n gt_labels (list[Tensor]): Ground truth labels of each image\n with shape (num_obj, 4).\n img_metas (list[dict]): Meta information of each image, e.g.,\n image size, scaling factor, etc.\n gt_bboxes_ignore (list[Tensor]): Ignored gt bboxes of each image.\n Default: None.\n\n Returns:\n dict: Loss dict, comprise classification loss, regression loss and\n carl loss.\n \"\"\"\n featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]\n assert len(featmap_sizes) == self.anchor_generator.num_levels\n\n device = cls_scores[0].device\n\n anchor_list, valid_flag_list = self.get_anchors(\n featmap_sizes, img_metas, device=device)\n label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1\n cls_reg_targets = self.get_targets(\n anchor_list,\n valid_flag_list,\n gt_bboxes,\n img_metas,\n gt_bboxes_ignore_list=gt_bboxes_ignore,\n gt_labels_list=gt_labels,\n label_channels=label_channels,\n return_sampling_results=True)\n if cls_reg_targets is None:\n return None\n (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,\n num_total_pos, num_total_neg, sampling_results_list) = cls_reg_targets\n num_total_samples = (\n num_total_pos + num_total_neg if self.sampling else num_total_pos)\n\n # anchor number of multi levels\n num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]\n # concat all level anchors and flags to a single tensor\n concat_anchor_list = []\n for i in range(len(anchor_list)):\n concat_anchor_list.append(torch.cat(anchor_list[i]))\n all_anchor_list = images_to_levels(concat_anchor_list,\n num_level_anchors)\n\n num_imgs = len(img_metas)\n flatten_cls_scores = [\n cls_score.permute(0, 2, 3, 1).reshape(num_imgs, -1, label_channels)\n for cls_score in cls_scores\n ]\n flatten_cls_scores = torch.cat(\n flatten_cls_scores, dim=1).reshape(-1,\n flatten_cls_scores[0].size(-1))\n flatten_bbox_preds = [\n bbox_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1, 4)\n for bbox_pred in bbox_preds\n ]\n flatten_bbox_preds = torch.cat(\n flatten_bbox_preds, dim=1).view(-1, flatten_bbox_preds[0].size(-1))\n flatten_labels = torch.cat(labels_list, dim=1).reshape(-1)\n flatten_label_weights = torch.cat(\n label_weights_list, dim=1).reshape(-1)\n flatten_anchors = torch.cat(all_anchor_list, dim=1).reshape(-1, 4)\n flatten_bbox_targets = torch.cat(\n bbox_targets_list, dim=1).reshape(-1, 4)\n flatten_bbox_weights = torch.cat(\n bbox_weights_list, dim=1).reshape(-1, 4)\n\n # Apply ISR-P\n isr_cfg = self.train_cfg.get('isr', None)\n if isr_cfg is not None:\n all_targets = (flatten_labels, flatten_label_weights,\n flatten_bbox_targets, flatten_bbox_weights)\n with torch.no_grad():\n all_targets = isr_p(\n flatten_cls_scores,\n flatten_bbox_preds,\n all_targets,\n flatten_anchors,\n sampling_results_list,\n bbox_coder=self.bbox_coder,\n loss_cls=self.loss_cls,\n num_class=self.num_classes,\n **self.train_cfg.isr)\n (flatten_labels, flatten_label_weights, flatten_bbox_targets,\n flatten_bbox_weights) = all_targets\n\n # For convenience we compute loss once instead separating by fpn level,\n # so that we don't need to separate the weights by level again.\n # The result should be the same\n losses_cls = self.loss_cls(\n flatten_cls_scores,\n flatten_labels,\n flatten_label_weights,\n avg_factor=num_total_samples)\n losses_bbox = self.loss_bbox(\n flatten_bbox_preds,\n flatten_bbox_targets,\n flatten_bbox_weights,\n avg_factor=num_total_samples)\n loss_dict = dict(loss_cls=losses_cls, loss_bbox=losses_bbox)\n\n # CARL Loss\n carl_cfg = self.train_cfg.get('carl', None)\n if carl_cfg is not None:\n loss_carl = carl_loss(\n flatten_cls_scores,\n flatten_labels,\n flatten_bbox_preds,\n flatten_bbox_targets,\n self.loss_bbox,\n **self.train_cfg.carl,\n avg_factor=num_total_pos,\n sigmoid=True,\n num_class=self.num_classes)\n loss_dict.update(loss_carl)\n\n return loss_dict\n",
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom mmcv.cnn import xavier_init\n\nfrom mmdet.core import (build_anchor_generator, build_assigner,\n build_bbox_coder, build_sampler, multi_apply)\nfrom ..builder import HEADS\nfrom ..losses import smooth_l1_loss\nfrom .anchor_head import AnchorHead\n\n\n# TODO: add loss evaluator for SSD\[email protected]_module()\nclass SSDHead(AnchorHead):\n \"\"\"SSD head used in https://arxiv.org/abs/1512.02325.\n\n Args:\n num_classes (int): Number of categories excluding the background\n category.\n in_channels (int): Number of channels in the input feature map.\n anchor_generator (dict): Config dict for anchor generator\n background_label (int | None): Label ID of background, set as 0 for\n RPN and num_classes for other heads. It will automatically set as\n num_classes if None is given.\n bbox_coder (dict): Config of bounding box coder.\n reg_decoded_bbox (bool): If true, the regression loss would be\n applied on decoded bounding boxes. Default: False\n train_cfg (dict): Training config of anchor head.\n test_cfg (dict): Testing config of anchor head.\n \"\"\" # noqa: W605\n\n def __init__(self,\n num_classes=80,\n in_channels=(512, 1024, 512, 256, 256, 256),\n anchor_generator=dict(\n type='SSDAnchorGenerator',\n scale_major=False,\n input_size=300,\n strides=[8, 16, 32, 64, 100, 300],\n ratios=([2], [2, 3], [2, 3], [2, 3], [2], [2]),\n basesize_ratio_range=(0.1, 0.9)),\n background_label=None,\n bbox_coder=dict(\n type='DeltaXYWHBBoxCoder',\n target_means=[.0, .0, .0, .0],\n target_stds=[1.0, 1.0, 1.0, 1.0],\n ),\n reg_decoded_bbox=False,\n train_cfg=None,\n test_cfg=None):\n super(AnchorHead, self).__init__()\n self.num_classes = num_classes\n self.in_channels = in_channels\n self.cls_out_channels = num_classes + 1 # add background class\n self.anchor_generator = build_anchor_generator(anchor_generator)\n num_anchors = self.anchor_generator.num_base_anchors\n\n reg_convs = []\n cls_convs = []\n for i in range(len(in_channels)):\n reg_convs.append(\n nn.Conv2d(\n in_channels[i],\n num_anchors[i] * 4,\n kernel_size=3,\n padding=1))\n cls_convs.append(\n nn.Conv2d(\n in_channels[i],\n num_anchors[i] * (num_classes + 1),\n kernel_size=3,\n padding=1))\n self.reg_convs = nn.ModuleList(reg_convs)\n self.cls_convs = nn.ModuleList(cls_convs)\n\n self.background_label = (\n num_classes if background_label is None else background_label)\n # background_label should be either 0 or num_classes\n assert (self.background_label == 0\n or self.background_label == num_classes)\n\n self.bbox_coder = build_bbox_coder(bbox_coder)\n self.reg_decoded_bbox = reg_decoded_bbox\n self.use_sigmoid_cls = False\n self.cls_focal_loss = False\n self.train_cfg = train_cfg\n self.test_cfg = test_cfg\n # set sampling=False for archor_target\n self.sampling = False\n if self.train_cfg:\n self.assigner = build_assigner(self.train_cfg.assigner)\n # SSD sampling=False so use PseudoSampler\n sampler_cfg = dict(type='PseudoSampler')\n self.sampler = build_sampler(sampler_cfg, context=self)\n self.fp16_enabled = False\n\n def init_weights(self):\n \"\"\"Initialize weights of the head.\"\"\"\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n xavier_init(m, distribution='uniform', bias=0)\n\n def forward(self, feats):\n \"\"\"Forward features from the upstream network.\n\n Args:\n feats (tuple[Tensor]): Features from the upstream network, each is\n a 4D-tensor.\n\n Returns:\n tuple:\n cls_scores (list[Tensor]): Classification scores for all scale\n levels, each is a 4D-tensor, the channels number is\n num_anchors * num_classes.\n bbox_preds (list[Tensor]): Box energies / deltas for all scale\n levels, each is a 4D-tensor, the channels number is\n num_anchors * 4.\n \"\"\"\n cls_scores = []\n bbox_preds = []\n for feat, reg_conv, cls_conv in zip(feats, self.reg_convs,\n self.cls_convs):\n cls_scores.append(cls_conv(feat))\n bbox_preds.append(reg_conv(feat))\n return cls_scores, bbox_preds\n\n def loss_single(self, cls_score, bbox_pred, anchor, labels, label_weights,\n bbox_targets, bbox_weights, num_total_samples):\n \"\"\"Compute loss of a single image.\n\n Args:\n cls_score (Tensor): Box scores for eachimage\n Has shape (num_total_anchors, num_classes).\n bbox_pred (Tensor): Box energies / deltas for each image\n level with shape (num_total_anchors, 4).\n anchors (Tensor): Box reference for each scale level with shape\n (num_total_anchors, 4).\n labels (Tensor): Labels of each anchors with shape\n (num_total_anchors,).\n label_weights (Tensor): Label weights of each anchor with shape\n (num_total_anchors,)\n bbox_targets (Tensor): BBox regression targets of each anchor wight\n shape (num_total_anchors, 4).\n bbox_weights (Tensor): BBox regression loss weights of each anchor\n with shape (num_total_anchors, 4).\n num_total_samples (int): If sampling, num total samples equal to\n the number of total anchors; Otherwise, it is the number of\n positive anchors.\n\n Returns:\n dict[str, Tensor]: A dictionary of loss components.\n \"\"\"\n\n loss_cls_all = F.cross_entropy(\n cls_score, labels, reduction='none') * label_weights\n # FG cat_id: [0, num_classes -1], BG cat_id: num_classes\n pos_inds = ((labels >= 0) &\n (labels < self.background_label)).nonzero().reshape(-1)\n neg_inds = (labels == self.background_label).nonzero().view(-1)\n\n num_pos_samples = pos_inds.size(0)\n num_neg_samples = self.train_cfg.neg_pos_ratio * num_pos_samples\n if num_neg_samples > neg_inds.size(0):\n num_neg_samples = neg_inds.size(0)\n topk_loss_cls_neg, _ = loss_cls_all[neg_inds].topk(num_neg_samples)\n loss_cls_pos = loss_cls_all[pos_inds].sum()\n loss_cls_neg = topk_loss_cls_neg.sum()\n loss_cls = (loss_cls_pos + loss_cls_neg) / num_total_samples\n\n if self.reg_decoded_bbox:\n bbox_pred = self.bbox_coder.decode(anchor, bbox_pred)\n\n loss_bbox = smooth_l1_loss(\n bbox_pred,\n bbox_targets,\n bbox_weights,\n beta=self.train_cfg.smoothl1_beta,\n avg_factor=num_total_samples)\n return loss_cls[None], loss_bbox\n\n def loss(self,\n cls_scores,\n bbox_preds,\n gt_bboxes,\n gt_labels,\n img_metas,\n gt_bboxes_ignore=None):\n \"\"\"Compute losses of the head.\n\n Args:\n cls_scores (list[Tensor]): Box scores for each scale level\n Has shape (N, num_anchors * num_classes, H, W)\n bbox_preds (list[Tensor]): Box energies / deltas for each scale\n level with shape (N, num_anchors * 4, H, W)\n gt_bboxes (list[Tensor]): each item are the truth boxes for each\n image in [tl_x, tl_y, br_x, br_y] format.\n gt_labels (list[Tensor]): class indices corresponding to each box\n img_metas (list[dict]): Meta information of each image, e.g.,\n image size, scaling factor, etc.\n gt_bboxes_ignore (None | list[Tensor]): specify which bounding\n boxes can be ignored when computing the loss.\n\n Returns:\n dict[str, Tensor]: A dictionary of loss components.\n \"\"\"\n featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]\n assert len(featmap_sizes) == self.anchor_generator.num_levels\n\n device = cls_scores[0].device\n\n anchor_list, valid_flag_list = self.get_anchors(\n featmap_sizes, img_metas, device=device)\n cls_reg_targets = self.get_targets(\n anchor_list,\n valid_flag_list,\n gt_bboxes,\n img_metas,\n gt_bboxes_ignore_list=gt_bboxes_ignore,\n gt_labels_list=gt_labels,\n label_channels=1,\n unmap_outputs=False)\n if cls_reg_targets is None:\n return None\n (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,\n num_total_pos, num_total_neg) = cls_reg_targets\n\n num_images = len(img_metas)\n all_cls_scores = torch.cat([\n s.permute(0, 2, 3, 1).reshape(\n num_images, -1, self.cls_out_channels) for s in cls_scores\n ], 1)\n all_labels = torch.cat(labels_list, -1).view(num_images, -1)\n all_label_weights = torch.cat(label_weights_list,\n -1).view(num_images, -1)\n all_bbox_preds = torch.cat([\n b.permute(0, 2, 3, 1).reshape(num_images, -1, 4)\n for b in bbox_preds\n ], -2)\n all_bbox_targets = torch.cat(bbox_targets_list,\n -2).view(num_images, -1, 4)\n all_bbox_weights = torch.cat(bbox_weights_list,\n -2).view(num_images, -1, 4)\n\n # concat all level anchors to a single tensor\n all_anchors = []\n for i in range(num_images):\n all_anchors.append(torch.cat(anchor_list[i]))\n\n # check NaN and Inf\n assert torch.isfinite(all_cls_scores).all().item(), \\\n 'classification scores become infinite or NaN!'\n assert torch.isfinite(all_bbox_preds).all().item(), \\\n 'bbox predications become infinite or NaN!'\n\n losses_cls, losses_bbox = multi_apply(\n self.loss_single,\n all_cls_scores,\n all_bbox_preds,\n all_anchors,\n all_labels,\n all_label_weights,\n all_bbox_targets,\n all_bbox_weights,\n num_total_samples=num_total_pos)\n return dict(loss_cls=losses_cls, loss_bbox=losses_bbox)\n"
] | [
[
"torch.cat",
"torch.no_grad"
],
[
"torch.cat",
"torch.nn.ModuleList",
"torch.isfinite",
"torch.nn.functional.cross_entropy",
"torch.nn.Conv2d"
]
] |
microsoft/iclr2019-learning-to-represent-edits | [
"e5777d6aa6cdeda500cf076646177c48d1cb4622"
] | [
"diff_representation/model/edit_encoder/bag_of_edits_change_encoder.py"
] | [
"# Copyright (c) Microsoft Corporation.\n# Licensed under the MIT license.\nfrom itertools import chain\n\nimport numpy as np\nimport torch\nfrom torch import nn as nn\nfrom torch.autograd import Variable\nfrom torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence\nfrom tqdm import tqdm\nimport sys\n\nfrom diff_representation.change_entry import ChangeExample\nfrom diff_representation.model import nn_utils\nfrom diff_representation.model.embedder import EmbeddingTable\n\n\nclass BagOfEditsChangeEncoder(nn.Module):\n \"\"\"project a CodeChange instance into distributed vectors\"\"\"\n\n def __init__(self, token_embedder, vocab, **kwargs):\n super(BagOfEditsChangeEncoder, self).__init__()\n\n self.token_embedder = token_embedder\n self.token_embedding_size = self.token_embedder.weight.size(1)\n self.vocab = vocab\n self.change_vector_size = self.token_embedding_size * 2\n\n @property\n def device(self):\n return self.token_embedder.device\n\n def forward(self, code_changes, *args, **kwargs):\n \"\"\"\n given the token encodings of the previous and updated code,\n and the diff information (alignment between the tokens between the\n previous and updated code), generate the diff representation\n \"\"\"\n\n added_tokens = []\n added_token_batch_ids = []\n deled_tokens = []\n deled_token_batch_ids = []\n for e_id, example in enumerate(code_changes):\n for entry in example.change_seq:\n tag, token = entry\n if tag == 'ADD':\n token_id = self.vocab[token]\n added_tokens.append(token_id)\n added_token_batch_ids.append(e_id)\n elif tag == 'DEL':\n token_id = self.vocab[token]\n deled_tokens.append(token_id)\n deled_token_batch_ids.append(e_id)\n elif tag == 'REPLACE':\n added_token_id = self.vocab[token[1]]\n deled_token_id = self.vocab[token[0]]\n\n added_tokens.append(added_token_id)\n deled_tokens.append(deled_token_id)\n\n added_token_batch_ids.append(e_id)\n deled_token_batch_ids.append(e_id)\n\n changed_token_ids = added_tokens + deled_tokens\n changed_token_ids = torch.tensor(changed_token_ids, dtype=torch.long, device=self.device)\n # (token_num, embed_size)\n changed_token_embeds = self.token_embedder.weight[changed_token_ids]\n\n added_token_embeds = changed_token_embeds[:len(added_tokens)]\n deled_token_embeds = changed_token_embeds[len(added_tokens):]\n\n added_change_embeds = torch.zeros(len(code_changes), self.token_embedding_size, dtype=torch.float,\n device=self.device)\n if added_token_batch_ids:\n added_change_embeds = added_change_embeds.scatter_add_(0,\n torch.tensor(added_token_batch_ids, device=self.device).unsqueeze(-1).expand_as(added_token_embeds),\n added_token_embeds)\n\n deled_change_embeds = torch.zeros(len(code_changes), self.token_embedding_size, dtype=torch.float,\n device=self.device)\n if deled_token_batch_ids:\n deled_change_embeds = deled_change_embeds.scatter_add_(0,\n torch.tensor(deled_token_batch_ids, device=self.device).unsqueeze(-1).expand_as(deled_token_embeds),\n deled_token_embeds)\n\n change_vectors = torch.cat([added_change_embeds, deled_change_embeds], dim=-1)\n\n return change_vectors\n\n def encode_code_change(self, prev_code_tokens, updated_code_tokens, code_encoder):\n example = ChangeExample(prev_code_tokens, updated_code_tokens, context=None)\n\n change_vec = self.forward([example]).data.cpu().numpy()[0]\n\n return change_vec\n\n def encode_code_changes(self, examples, code_encoder, batch_size=32):\n \"\"\"encode each change in the list `code_changes`,\n return a 2D numpy array of shape (len(code_changes), code_change_embed_dim)\"\"\"\n\n change_vecs = []\n\n for batch_examples in tqdm(nn_utils.batch_iter(examples, batch_size), file=sys.stdout, total=len(examples)):\n batch_change_vecs = self.forward(batch_examples).data.cpu().numpy()\n change_vecs.append(batch_change_vecs)\n\n change_vecs = np.concatenate(change_vecs, axis=0)\n\n return change_vecs\n"
] | [
[
"numpy.concatenate",
"torch.cat",
"torch.tensor"
]
] |
junarwohn/tvm | [
"96c2e06cd063a695b3b485f2bdf8875df55fff1a",
"96c2e06cd063a695b3b485f2bdf8875df55fff1a"
] | [
"tvm_test/run_simple_mod_op2_pth.py",
"tvm_test/run_op2_pth.py"
] | [
"import tvm\nfrom tvm import relay\nfrom tvm import relay\nfrom tvm.runtime.vm import VirtualMachine\nfrom tvm.contrib.download import download_testdata\nfrom SimpleModel import Net\nimport numpy as np\nimport cv2\n\n# PyTorch imports\nimport torch\nimport torchvision\n\n# Time library for speed check\nimport time\n\nin_size = 32\n\ninput_shape = (1, 3, in_size, in_size)\n\n\ndef do_trace(model, inp):\n model_trace = torch.jit.trace(model, inp)\n model_trace.eval()\n return model_trace\n\n\n# model_func = torchvision.models.detection.maskrcnn_resnet50_fpn\n# model = TraceWrapper(model_func(pretrained=True))\n\nmodel = Net()\nmodel.load_state_dict(torch.load('./simple_mod.pth'))\n\nmodel.eval()\ninp = torch.Tensor(np.random.uniform(0.0, 250.0, size=(1, 3, in_size, in_size)))\n\nwith torch.no_grad():\n out = model(inp)\n script_module = do_trace(model, inp)\n \n\nimg_url = (\n \"https://raw.githubusercontent.com/dmlc/web-data/\" \"master/gluoncv/detection/street_small.jpg\"\n)\nimg_path = download_testdata(img_url, \"test_street_small.jpg\", module=\"data\")\n\nimg = cv2.imread(img_path).astype(\"float32\")\nimg = cv2.resize(img, (in_size, in_size))\nimg = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\nimg = np.transpose(img / 255.0, [2, 0, 1])\nimg = np.expand_dims(img, axis=0)\n\ninput_name = \"input0\"\nshape_list = [(input_name, input_shape)]\nmod, params = relay.frontend.from_pytorch(script_module, shape_list)\n\ntarget = \"llvm\"\n\nwith tvm.transform.PassContext(opt_level=2, disabled_pass=[\"FoldScaleAxis\"]):\n vm_exec = relay.vm.compile(mod, target=target, params=params)\n\n# dev = tvm.cuda()\ndev = tvm.cpu()\nvm = VirtualMachine(vm_exec, dev)\nvm.set_input(\"main\", **{input_name: img})\ninference_start = time.time()\ntvm_res = vm.run()\ninference_end = time.time()\ninference_time_tvm = inference_end - inference_start\nprint(\"Infernece Time : {}\".format(inference_time_tvm))\n\n\n",
"import tvm\nfrom tvm import relay\nfrom tvm import relay\nfrom tvm.runtime.vm import VirtualMachine\nfrom tvm.contrib.download import download_testdata\n\nimport numpy as np\nimport cv2\n\n# PyTorch imports\nimport torch\nimport torchvision\n\n# Time library for speed check\nimport time\n\nin_size = 300\n\ninput_shape = (1, 3, in_size, in_size)\n\n\ndef do_trace(model, inp):\n model_trace = torch.jit.trace(model, inp)\n model_trace.eval()\n return model_trace\n\n\ndef dict_to_tuple(out_dict):\n if \"masks\" in out_dict.keys():\n return out_dict[\"boxes\"], out_dict[\"scores\"], out_dict[\"labels\"], out_dict[\"masks\"]\n return out_dict[\"boxes\"], out_dict[\"scores\"], out_dict[\"labels\"]\n\n\nclass TraceWrapper(torch.nn.Module):\n def __init__(self, model):\n super().__init__()\n self.model = model\n\n def forward(self, inp):\n out = self.model(inp)\n return dict_to_tuple(out[0])\n\n\nmodel_func = torchvision.models.detection.maskrcnn_resnet50_fpn\nmodel = TraceWrapper(model_func(pretrained=True))\n\nmodel.eval()\ninp = torch.Tensor(np.random.uniform(0.0, 250.0, size=(1, 3, in_size, in_size)))\n\nwith torch.no_grad():\n out = model(inp)\n script_module = do_trace(model, inp)\n \n\nimg_url = (\n \"https://raw.githubusercontent.com/dmlc/web-data/\" \"master/gluoncv/detection/street_small.jpg\"\n)\nimg_path = download_testdata(img_url, \"test_street_small.jpg\", module=\"data\")\n\nimg = cv2.imread(img_path).astype(\"float32\")\nimg = cv2.resize(img, (in_size, in_size))\nimg = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\nimg = np.transpose(img / 255.0, [2, 0, 1])\nimg = np.expand_dims(img, axis=0)\n\ninput_name = \"input0\"\nshape_list = [(input_name, input_shape)]\nmod, params = relay.frontend.from_pytorch(script_module, shape_list)\n\ntarget = \"llvm\"\n\nwith tvm.transform.PassContext(opt_level=2, disabled_pass=[\"FoldScaleAxis\"]):\n vm_exec = relay.vm.compile(mod, target=target, params=params)\n\n# dev = tvm.cuda()\ndev = tvm.cpu()\nvm = VirtualMachine(vm_exec, dev)\nvm.set_input(\"main\", **{input_name: img})\n\ntest_trial = 10\ntotal_time = 0\n\nfor i in range(test_trial):\n inference_start = time.time()\n tvm_res = vm.run()\n inference_end = time.time()\n inference_time_tvm = inference_end - inference_start\n total_time += inference_time_tvm\n print(\"Infernece Time : {}\".format(inference_time_tvm), end=' ')\n\nprint(\"Avg time : {}\".format(total_time / test_trial))\n\n\nscore_threshold = 0.9\nboxes = tvm_res[0].numpy().tolist()\nvalid_boxes = []\nfor i, score in enumerate(tvm_res[1].numpy().tolist()):\n if score > score_threshold:\n valid_boxes.append(boxes[i])\n else:\n break\n\nprint(\"Get {} valid boxes\".format(len(valid_boxes)))\n\n"
] | [
[
"torch.no_grad",
"numpy.random.uniform",
"numpy.transpose",
"torch.jit.trace",
"torch.load",
"numpy.expand_dims"
],
[
"torch.no_grad",
"numpy.random.uniform",
"numpy.transpose",
"torch.jit.trace",
"numpy.expand_dims"
]
] |
rogerfitz/tutorials | [
"dae6470bad63b71e755caaff0b69893f5c9a1d63"
] | [
"travel_time_visualization/server.py"
] | [
"from flask import Flask, jsonify,render_template,request\nfrom config import API_KEY\nimport datetime\nfrom collections import defaultdict\nimport requests\nimport pandas as pd\nimport sys\nimport logging\nfrom itertools import repeat\n\napp = Flask(__name__)\ngunicorn_error_logger = logging.getLogger('gunicorn.error')\napp.logger.handlers.extend(gunicorn_error_logger.handlers)\napp.logger.setLevel(logging.DEBUG)\n\nfrom multiprocessing.dummy import Pool as ThreadPool \npool = ThreadPool(20) \nBASE_URL=\"https://maps.googleapis.com/maps/api/\"\napp.logger.debug(datetime.datetime.fromtimestamp(1498924020))\n\nclass GAPIError(Exception):\n status_code = 31337\n\n def __init__(self, message, status_code=None, payload=None):\n Exception.__init__(self)\n self.message = message\n if status_code is not None:\n self.status_code = status_code\n self.payload = payload\n\n def to_dict(self):\n rv = dict(self.payload or ())\n rv['message'] = self.message\n return rv\n\ndef makeRequest(url, API_KEY):\n url+=\"&key=%s\"%API_KEY\n return requests.get(url).json()['rows'][0]['elements'][0]['duration_in_traffic']['value']\ndef getDistanceMatrix(origin,destination,mode,departure_time,traffic_model, API_KEY):\n #UTC Time\n url=BASE_URL+\"distancematrix/json?\"\n params=\"origins=%s&destinations=%s&mode=%s&departure_time=%s&traffic_model=%s\"%(origin,destination,mode,departure_time,traffic_model)\n return makeRequest(url+params, API_KEY)\n\ndef getNearest(dt,offset):\n return dt + (datetime.datetime.min - dt) % datetime.timedelta(minutes=offset)\n\ndef getChartData(starting_address,destination_address, leave_after, hours_to_grab,API_KEY,OFFSET=15):\n start_date=getNearest(leave_after,15)\n request_times=defaultdict(dict)\n dts=[int(leave_after.timestamp())]\n \n for dt in (start_date + datetime.timedelta(minutes=offset) for offset in range(0,60*hours_to_grab,OFFSET)):\n dts.append(int(dt.timestamp()))\n \n request_times={}\n for traffic_model in [\"best_guess\",\"pessimistic\",\"optimistic\"]:\n results=pool.starmap(\n getDistanceMatrix, zip(repeat(starting_address),repeat(destination_address),repeat(\"car\"),dts,repeat(traffic_model), repeat(API_KEY))\n )\n request_times[traffic_model]=results\n request_times[\"index\"]=dts\n travel_times=pd.DataFrame.from_dict(request_times).set_index(\"index\")/60\n viz_df=travel_times.reset_index()\n viz_df['x']=viz_df['index']*1000#Add milliseconds for JS datetime\n del viz_df['index']\n viz_json=viz_df.to_dict(orient=\"list\")\n #to c3 Columns\n columns=[]\n for col,vals in viz_json.items():\n if col!=\"x\":\n vals=[round(x) for x in vals]\n columns.append([col]+vals)\n return columns\n\[email protected](\"/\")\ndef index():\n return render_template('index.html', API_KEY=API_KEY)\n \[email protected]('/data')\ndef data():\n app.logger.debug(request.args) \n leaveAfter=request.args.get(\"leaveAfter\")\n leaveAfter=datetime.datetime.fromtimestamp(int(leaveAfter)/1000)\n USERS_API_KEY=request.args.get(\"API_KEY\",default=API_KEY)\n now=datetime.datetime.now()\n if leaveAfter<now:\n leaveAfter=now\n try:\n response=getChartData(request.args.get(\"startingAddress\"),request.args.get(\"destinationAddress\"),leaveAfter,8, USERS_API_KEY)\n return jsonify(response)\n except:\n raise GAPIError(\"API Key no longer valid\", status_code=31337)\n \n \[email protected](GAPIError)\ndef handle_invalid_usage(error):\n response = jsonify(error.to_dict())\n response.status_code = error.status_code\n return response\n \nif __name__ == '__main__':\n app.run(host='0.0.0.0', port=5000)\n"
] | [
[
"pandas.DataFrame.from_dict"
]
] |
mommy79/AuDi-GIT-turtlebot3_autorace | [
"fd1382246f1ee74ee70857006563184d672a6666"
] | [
"src/mission_node/src/intersection_detector.py"
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\nimport numpy as np\nimport cv2\nimport math\n\n\nclass IntersectionDetector:\n def __init__(self):\n self.lower_blue = np.array([85, 90, 120], np.uint8)\n self.upper_blue = np.array([115, 255, 255], np.uint8)\n\n def fn_find_intersection_line(self, img_trans):\n # ROI 영역에 맞게 자른 이미지\n pers_height, pers_width = img_trans.shape[:2] # shape is w384 x h240\n img_gray = cv2.cvtColor(img_trans[:int(pers_height * 1/ 2), :].copy(), cv2.COLOR_RGB2GRAY)\n _, img_intersection = cv2.threshold(img_gray, 180, 255, 0)\n img_intersection = cv2.morphologyEx(img_intersection, cv2.MORPH_OPEN, np.ones((5, 5), np.uint8))\n img_intersection = cv2.morphologyEx(img_intersection, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))\n img_debug = cv2.merge((img_intersection, img_intersection, img_intersection)).copy()\n\n _, list_intersection_contour, _ = cv2.findContours(img_intersection, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\n intersection_check = False\n\n for intersection_contour in list_intersection_contour:\n cv2.drawContours(img_debug, [intersection_contour], 0, (0, 0, 255), 2)\n x_stop, y_stop, w_stop, h_stop = cv2.boundingRect(intersection_contour)\n cv2.putText(img_debug, 'w: {}, h: {}'.format(w_stop, h_stop), (intersection_contour[0][0][0]+10, intersection_contour[0][0][1]+10), cv2.FONT_HERSHEY_SIMPLEX, 0.2, (0, 255, 255))\n if 330 < w_stop:\n cv2.drawContours(img_debug, [intersection_contour], 0, (0, 255, 0), 2)\n intersection_check = True\n\n return intersection_check, img_debug\n\n def fn_find_exit_line(self, img_trans, direction='left'):\n # ROI 영역에 맞게 자른 이미지\n pers_height, pers_width = img_trans.shape[:2] # shape is w384 x h240\n if direction == 'left':\n img_gray = cv2.cvtColor(img_trans[:, int(pers_width * 1/ 2):].copy(), cv2.COLOR_RGB2GRAY)\n else:\n img_gray = cv2.cvtColor(img_trans[:, :int(pers_width * 1/ 2)].copy(), cv2.COLOR_RGB2GRAY)\n _, img_exit = cv2.threshold(img_gray, 190, 255, 0)\n img_exit = cv2.morphologyEx(img_exit, cv2.MORPH_OPEN, np.ones((5, 5), np.uint8))\n img_exit = cv2.morphologyEx(img_exit, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))\n img_debug = cv2.merge((img_exit, img_exit, img_exit)).copy()\n\n _, list_exit_contour, _ = cv2.findContours(img_exit, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\n exit_check = False\n exit_pos = (0, 0)\n\n for exit_contour in list_exit_contour:\n cv2.drawContours(img_debug, [exit_contour], 0, (0, 0, 255), 2)\n x_exit, y_exit, w_exit, h_exit = cv2.boundingRect(exit_contour)\n bottom_most_pos = tuple(exit_contour[exit_contour[:, :, 1].argmax()][0])\n val_height = h_exit\n for pos_y in range(pers_height-1, 0, -1):\n if img_gray[pos_y, bottom_most_pos[0]] != 0:\n val_height = pos_y\n break\n\n cv2.putText(img_debug, 'w: {}, h: {}, length: {}'.format(w_exit, h_exit, val_height), (exit_contour[0][0][0]+10, exit_contour[0][0][1]+10), cv2.FONT_HERSHEY_SIMPLEX, 0.2, (0, 255, 255))\n\n if h_exit > val_height * 4/5 and h_exit > pers_height/2:\n cv2.drawContours(img_debug, [exit_contour], 0, (0, 255, 0), 2)\n exit_pos = exit_contour[0][0]\n exit_check = True\n\n return exit_check, exit_pos, img_debug\n\n def fn_find_direction_sign(self, img_ori):\n left_sign_detect = False\n right_sign_detect = False\n\n img_height, img_width = img_ori.shape[:2]\n img_roi = img_ori[:int(img_height*1 / 2), :].copy()\n img_hsv = cv2.cvtColor(img_roi, cv2.COLOR_BGR2HSV)\n\n # Hsv fillter - Blue color\n img_mask_b = cv2.inRange(img_hsv, self.lower_blue, self.upper_blue)\n img_mask_b = cv2.morphologyEx(img_mask_b, cv2.MORPH_OPEN, np.ones((7, 7), np.uint8))\n img_mask_b = cv2.morphologyEx(img_mask_b, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8))\n #_, list_obj_contour, _ = cv2.findContours(img_mask_b, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n _, list_obj_contour, _ = cv2.findContours(img_mask_b, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n\n img_blue = cv2.bitwise_and(img_roi, img_roi, mask=img_mask_b)\n img_debug = img_roi.copy()\n\n list_obj = []\n\n for obj_contour in list_obj_contour:\n #cv2.drawContours(img_blue, [contour], 0, (0, 0, 255), 2)\n x, y, w, h = cv2.boundingRect(obj_contour)\n area = cv2.contourArea(obj_contour)\n aspect_ratio = float(w) / h\n area_ratio = float(area) / (w*h)\n cv2.rectangle(img_debug, (x, y), (x + w, y + h), (0, 0, 255), 2)\n cv2.putText(img_debug, 'w: {}, h: {}, aspect_ratio: {:.2f}, area_ratio: {:.2f}'.format(w, h, aspect_ratio, area_ratio), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 127, 0))\n\n if (50 < w < 150) and (50 < h < 150) and (0.8 < aspect_ratio < 2.5) and (area_ratio > 0.5):\n cv2.rectangle(img_debug, (x, y), (x + w, y + h), (0, 255, 255), 2)\n list_obj.append((img_roi[y:y+h, x:x+w].copy(), (x, y, w, h)))\n\n for (img_obj, (obj_x, obj_y, obj_w, obj_h)) in list_obj:\n img_obj_gray = cv2.cvtColor(img_obj, cv2.COLOR_BGR2GRAY)\n _, img_obj_binary = cv2.threshold(img_obj_gray, 180, 255, cv2.THRESH_BINARY)\n img_obj_binary = cv2.morphologyEx(img_obj_binary, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8))\n _, list_arrow_contour, _ = cv2.findContours(img_obj_binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\n obj_x_mid = int(obj_w / 2)\n obj_y_mid = int(obj_h / 2)\n\n min_val_dis = 30\n bottom_most_pos = None\n\n for arrow_contour in list_arrow_contour:\n mask_arrow = np.zeros(img_obj_gray.shape, np.uint8)\n cv2.drawContours(mask_arrow, [arrow_contour], 0, 255, -1)\n arrow_x, arrow_y, arrow_w, arrow_h = cv2.boundingRect(arrow_contour)\n cv2.rectangle(img_debug, (obj_x + arrow_x, obj_y + arrow_y), (obj_x + arrow_x + arrow_w, arrow_y + obj_y + arrow_h), (255, 255, 0), 1)\n arrow_area = cv2.contourArea(arrow_contour)\n arrow_aspect_ratio = float(arrow_w) / arrow_h\n arrow_area_ratio = float(arrow_area) / (arrow_w * arrow_h)\n\n arrow_x_mid = int(arrow_x + arrow_w / 2)\n arrow_y_mid = int(arrow_y + arrow_h / 2)\n\n if (0.4 * obj_w < arrow_w) and (0.4 * obj_h < arrow_h) and (0.5 < arrow_aspect_ratio < 2) and (arrow_area_ratio > 0.3):\n val_dis = math.sqrt((arrow_x_mid - obj_x_mid) ** 2 + (arrow_y_mid - obj_y_mid) ** 2)\n if val_dis < min_val_dis:\n min_val_dis = val_dis\n\n #left_most_pos = tuple(obj_contour[obj_contour[:, :, 0].argmin()][0])\n #right_most_pos = tuple(obj_contour[obj_contour[:, :, 0].argmax()][0])\n #top_most_pos = tuple(obj_contour[obj_contour[:, :, 1].argmin()][0])\n bottom_most_pos = tuple(arrow_contour[arrow_contour[:, :, 1].argmax()][0])\n\n if bottom_most_pos is not None:\n cv2.circle(img_debug, (obj_x + bottom_most_pos[0], obj_y + bottom_most_pos[1]), 4, (0, 0, 255), -1)\n cv2.line(img_debug, (obj_x + obj_x_mid, obj_y), (obj_x + obj_x_mid, obj_y + obj_h), (255, 0, 255), 2)\n if bottom_most_pos[0] > obj_x_mid:\n left_sign_detect = True\n cv2.putText(img_debug, 'LEFT', (obj_x+10, obj_y+20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))\n cv2.rectangle(img_debug, (obj_x, obj_y), (obj_x + obj_w, obj_y + obj_h), (255, 0, 0), 2)\n else:\n right_sign_detect = True\n cv2.putText(img_debug, 'RIGHT', (obj_x+3, obj_y+20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))\n cv2.rectangle(img_debug, (obj_x, obj_y), (obj_x + obj_w, obj_y + obj_h), (0, 255, 0), 2)\n\n return left_sign_detect, right_sign_detect, np.vstack((img_debug, img_blue))\n"
] | [
[
"numpy.array",
"numpy.ones",
"numpy.zeros",
"numpy.vstack"
]
] |
ahoho/numpyro | [
"64e94e346c51a6c0c1ba51aa7b608e73513f158f",
"64e94e346c51a6c0c1ba51aa7b608e73513f158f"
] | [
"numpyro/distributions/transforms.py",
"numpyro/distributions/util.py"
] | [
"# Copyright Contributors to the Pyro project.\n# SPDX-License-Identifier: Apache-2.0\n\nimport math\nimport warnings\nimport weakref\n\nimport numpy as np\n\nfrom jax import lax, ops, tree_flatten, tree_map, vmap\nfrom jax.flatten_util import ravel_pytree\nfrom jax.nn import softplus\nimport jax.numpy as jnp\nfrom jax.scipy.linalg import solve_triangular\nfrom jax.scipy.special import expit, logit\n\nfrom numpyro.distributions import constraints\nfrom numpyro.distributions.util import matrix_to_tril_vec, signed_stick_breaking_tril, sum_rightmost, vec_to_tril_matrix\nfrom numpyro.util import not_jax_tracer\n\n__all__ = [\n 'biject_to',\n 'AbsTransform',\n 'AffineTransform',\n 'CholeskyTransform',\n 'ComposeTransform',\n 'CorrCholeskyTransform',\n 'CorrMatrixCholeskyTransform',\n 'ExpTransform',\n 'SoftplusTransform',\n 'IdentityTransform',\n 'InvCholeskyTransform',\n 'LowerCholeskyTransform',\n 'LowerCholeskyAffine',\n 'PermuteTransform',\n 'PowerTransform',\n 'SigmoidTransform',\n 'SoftplusTransform',\n 'SoftplusLowerCholeskyTransform',\n 'StickBreakingTransform',\n 'Transform',\n 'UnpackTransform',\n]\n\n\ndef _clipped_expit(x):\n finfo = jnp.finfo(jnp.result_type(x))\n return jnp.clip(expit(x), a_min=finfo.tiny, a_max=1. - finfo.eps)\n\n\nclass Transform(object):\n domain = constraints.real\n codomain = constraints.real\n _inv = None\n\n @property\n def event_dim(self):\n warnings.warn(\"transform.event_dim is deprecated. Please use Transform.domain.event_dim to \"\n \"get input event dim or Transform.codomain.event_dim to get output event dim.\",\n FutureWarning)\n return self.domain.event_dim\n\n @property\n def inv(self):\n inv = None\n if self._inv is not None:\n inv = self._inv()\n if inv is None:\n inv = _InverseTransform(self)\n self._inv = weakref.ref(inv)\n return inv\n\n def __call__(self, x):\n return NotImplementedError\n\n def _inverse(self, y):\n raise NotImplementedError\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n raise NotImplementedError\n\n def call_with_intermediates(self, x):\n return self(x), None\n\n def forward_shape(self, shape):\n \"\"\"\n Infers the shape of the forward computation, given the input shape.\n Defaults to preserving shape.\n \"\"\"\n return shape\n\n def inverse_shape(self, shape):\n \"\"\"\n Infers the shapes of the inverse computation, given the output shape.\n Defaults to preserving shape.\n \"\"\"\n return shape\n\n\nclass _InverseTransform(Transform):\n def __init__(self, transform):\n super().__init__()\n self._inv = transform\n\n @property\n def domain(self):\n return self._inv.codomain\n\n @property\n def codomain(self):\n return self._inv.domain\n\n @property\n def inv(self):\n return self._inv\n\n def __call__(self, x):\n return self._inv._inverse(x)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n # NB: we don't use intermediates for inverse transform\n return -self._inv.log_abs_det_jacobian(y, x, None)\n\n def forward_shape(self, shape):\n return self._inv.inverse_shape(shape)\n\n def inverse_shape(self, shape):\n return self._inv.forward_shape(shape)\n\n\nclass AbsTransform(Transform):\n domain = constraints.real\n codomain = constraints.positive\n\n def __eq__(self, other):\n return isinstance(other, AbsTransform)\n\n def __call__(self, x):\n return jnp.abs(x)\n\n def _inverse(self, y):\n return y\n\n\nclass AffineTransform(Transform):\n \"\"\"\n .. note:: When `scale` is a JAX tracer, we always assume that `scale > 0`\n when calculating `codomain`.\n \"\"\"\n def __init__(self, loc, scale, domain=constraints.real):\n self.loc = loc\n self.scale = scale\n self.domain = domain\n\n @property\n def codomain(self):\n if self.domain is constraints.real:\n return constraints.real\n elif isinstance(self.domain, constraints.greater_than):\n if not_jax_tracer(self.scale) and np.all(np.less(self.scale, 0)):\n return constraints.less_than(self(self.domain.lower_bound))\n # we suppose scale > 0 for any tracer\n else:\n return constraints.greater_than(self(self.domain.lower_bound))\n elif isinstance(self.domain, constraints.less_than):\n if not_jax_tracer(self.scale) and np.all(np.less(self.scale, 0)):\n return constraints.greater_than(self(self.domain.upper_bound))\n # we suppose scale > 0 for any tracer\n else:\n return constraints.less_than(self(self.domain.upper_bound))\n elif isinstance(self.domain, constraints.interval):\n if not_jax_tracer(self.scale) and np.all(np.less(self.scale, 0)):\n return constraints.interval(self(self.domain.upper_bound),\n self(self.domain.lower_bound))\n else:\n return constraints.interval(self(self.domain.lower_bound),\n self(self.domain.upper_bound))\n else:\n raise NotImplementedError\n\n def __call__(self, x):\n return self.loc + self.scale * x\n\n def _inverse(self, y):\n return (y - self.loc) / self.scale\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n return jnp.broadcast_to(jnp.log(jnp.abs(self.scale)), jnp.shape(x))\n\n def forward_shape(self, shape):\n return lax.broadcast_shapes(shape,\n getattr(self.loc, \"shape\", ()),\n getattr(self.scale, \"shape\", ()))\n\n def inverse_shape(self, shape):\n return lax.broadcast_shapes(shape,\n getattr(self.loc, \"shape\", ()),\n getattr(self.scale, \"shape\", ()))\n\n\ndef _get_compose_transform_input_event_dim(parts):\n input_event_dim = parts[-1].domain.event_dim\n for part in parts[len(parts) - 1::-1]:\n input_event_dim = part.domain.event_dim + max(input_event_dim - part.codomain.event_dim, 0)\n return input_event_dim\n\n\ndef _get_compose_transform_output_event_dim(parts):\n output_event_dim = parts[0].codomain.event_dim\n for part in parts[1:]:\n output_event_dim = part.codomain.event_dim + max(output_event_dim - part.domain.event_dim, 0)\n return output_event_dim\n\n\nclass ComposeTransform(Transform):\n def __init__(self, parts):\n self.parts = parts\n\n @property\n def domain(self):\n input_event_dim = _get_compose_transform_input_event_dim(self.parts)\n first_input_event_dim = self.parts[0].domain.event_dim\n assert input_event_dim >= first_input_event_dim\n if input_event_dim == first_input_event_dim:\n return self.parts[0].domain\n else:\n return constraints.independent(self.parts[0].domain, input_event_dim - first_input_event_dim)\n\n @property\n def codomain(self):\n output_event_dim = _get_compose_transform_output_event_dim(self.parts)\n last_output_event_dim = self.parts[-1].codomain.event_dim\n assert output_event_dim >= last_output_event_dim\n if output_event_dim == last_output_event_dim:\n return self.parts[-1].codomain\n else:\n return constraints.independent(self.parts[-1].codomain, output_event_dim - last_output_event_dim)\n\n def __call__(self, x):\n for part in self.parts:\n x = part(x)\n return x\n\n def _inverse(self, y):\n for part in self.parts[::-1]:\n y = part.inv(y)\n return y\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n if intermediates is not None:\n if len(intermediates) != len(self.parts):\n raise ValueError('Intermediates array has length = {}. Expected = {}.'\n .format(len(intermediates), len(self.parts)))\n\n result = 0.\n input_event_dim = self.domain.event_dim\n for i, part in enumerate(self.parts[:-1]):\n y_tmp = part(x) if intermediates is None else intermediates[i][0]\n inter = None if intermediates is None else intermediates[i][1]\n logdet = part.log_abs_det_jacobian(x, y_tmp, intermediates=inter)\n batch_ndim = input_event_dim - part.domain.event_dim\n result = result + sum_rightmost(logdet, batch_ndim)\n input_event_dim = part.codomain.event_dim + batch_ndim\n x = y_tmp\n # account the the last transform, where y is available\n inter = None if intermediates is None else intermediates[-1]\n part = self.parts[-1]\n logdet = part.log_abs_det_jacobian(x, y, intermediates=inter)\n result = result + sum_rightmost(logdet, input_event_dim - part.domain.event_dim)\n return result\n\n def call_with_intermediates(self, x):\n intermediates = []\n for part in self.parts[:-1]:\n x, inter = part.call_with_intermediates(x)\n intermediates.append([x, inter])\n # NB: we don't need to hold the last output value in `intermediates`\n x, inter = self.parts[-1].call_with_intermediates(x)\n intermediates.append(inter)\n return x, intermediates\n\n def forward_shape(self, shape):\n for part in self.parts:\n shape = part.forward_shape(shape)\n return shape\n\n def inverse_shape(self, shape):\n for part in reversed(self.parts):\n shape = part.inverse_shape(shape)\n return shape\n\n\ndef _matrix_forward_shape(shape, offset=0):\n # Reshape from (..., N) to (..., D, D).\n if len(shape) < 1:\n raise ValueError(\"Too few dimensions in input\")\n N = shape[-1]\n D = round((0.25 + 2 * N) ** 0.5 - 0.5)\n if D * (D + 1) // 2 != N:\n raise ValueError(\"Input is not a flattend lower-diagonal number\")\n D = D - offset\n return shape[:-1] + (D, D)\n\n\ndef _matrix_inverse_shape(shape, offset=0):\n # Reshape from (..., D, D) to (..., N).\n if len(shape) < 2:\n raise ValueError(\"Too few dimensions on input\")\n if shape[-2] != shape[-1]:\n raise ValueError(\"Input is not square\")\n D = shape[-1] + offset\n N = D * (D + 1) // 2\n return shape[:-2] + (N,)\n\n\nclass CholeskyTransform(Transform):\n r\"\"\"\n Transform via the mapping :math:`y = cholesky(x)`, where `x` is a\n positive definite matrix.\n \"\"\"\n domain = constraints.positive_definite\n codomain = constraints.lower_cholesky\n\n def __call__(self, x):\n return jnp.linalg.cholesky(x)\n\n def _inverse(self, y):\n return jnp.matmul(y, jnp.swapaxes(y, -2, -1))\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n # Ref: http://web.mit.edu/18.325/www/handouts/handout2.pdf page 13\n n = jnp.shape(x)[-1]\n order = -jnp.arange(n, 0, -1)\n return -n * jnp.log(2) + jnp.sum(order * jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1)), axis=-1)\n\n\nclass CorrCholeskyTransform(Transform):\n r\"\"\"\n Transforms a uncontrained real vector :math:`x` with length :math:`D*(D-1)/2` into the\n Cholesky factor of a D-dimension correlation matrix. This Cholesky factor is a lower\n triangular matrix with positive diagonals and unit Euclidean norm for each row.\n The transform is processed as follows:\n\n 1. First we convert :math:`x` into a lower triangular matrix with the following order:\n\n .. math::\n \\begin{bmatrix}\n 1 & 0 & 0 & 0 \\\\\n x_0 & 1 & 0 & 0 \\\\\n x_1 & x_2 & 1 & 0 \\\\\n x_3 & x_4 & x_5 & 1\n \\end{bmatrix}\n\n 2. For each row :math:`X_i` of the lower triangular part, we apply a *signed* version of\n class :class:`StickBreakingTransform` to transform :math:`X_i` into a\n unit Euclidean length vector using the following steps:\n\n a. Scales into the interval :math:`(-1, 1)` domain: :math:`r_i = \\tanh(X_i)`.\n b. Transforms into an unsigned domain: :math:`z_i = r_i^2`.\n c. Applies :math:`s_i = StickBreakingTransform(z_i)`.\n d. Transforms back into signed domain: :math:`y_i = (sign(r_i), 1) * \\sqrt{s_i}`.\n \"\"\"\n domain = constraints.real_vector\n codomain = constraints.corr_cholesky\n\n def __call__(self, x):\n # we interchange step 1 and step 2.a for a better performance\n t = jnp.tanh(x)\n return signed_stick_breaking_tril(t)\n\n def _inverse(self, y):\n # inverse stick-breaking\n z1m_cumprod = 1 - jnp.cumsum(y * y, axis=-1)\n pad_width = [(0, 0)] * y.ndim\n pad_width[-1] = (1, 0)\n z1m_cumprod_shifted = jnp.pad(z1m_cumprod[..., :-1], pad_width,\n mode=\"constant\", constant_values=1.)\n t = matrix_to_tril_vec(y, diagonal=-1) / jnp.sqrt(\n matrix_to_tril_vec(z1m_cumprod_shifted, diagonal=-1))\n # inverse of tanh\n x = jnp.log((1 + t) / (1 - t)) / 2\n return x\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n # NB: because domain and codomain are two spaces with different dimensions, determinant of\n # Jacobian is not well-defined. Here we return `log_abs_det_jacobian` of `x` and the\n # flatten lower triangular part of `y`.\n\n # stick_breaking_logdet = log(y / r) = log(z_cumprod) (modulo right shifted)\n z1m_cumprod = 1 - jnp.cumsum(y * y, axis=-1)\n # by taking diagonal=-2, we don't need to shift z_cumprod to the right\n # NB: diagonal=-2 works fine for (2 x 2) matrix, where we get an empty array\n z1m_cumprod_tril = matrix_to_tril_vec(z1m_cumprod, diagonal=-2)\n stick_breaking_logdet = 0.5 * jnp.sum(jnp.log(z1m_cumprod_tril), axis=-1)\n\n tanh_logdet = -2 * jnp.sum(x + softplus(-2 * x) - jnp.log(2.), axis=-1)\n return stick_breaking_logdet + tanh_logdet\n\n def forward_shape(self, shape):\n return _matrix_forward_shape(shape, offset=-1)\n\n def inverse_shape(self, shape):\n return _matrix_inverse_shape(shape, offset=-1)\n\n\nclass CorrMatrixCholeskyTransform(CholeskyTransform):\n r\"\"\"\n Transform via the mapping :math:`y = cholesky(x)`, where `x` is a\n correlation matrix.\n \"\"\"\n domain = constraints.corr_matrix\n codomain = constraints.corr_cholesky\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n # NB: see derivation in LKJCholesky implementation\n n = jnp.shape(x)[-1]\n order = -jnp.arange(n - 1, -1, -1)\n return jnp.sum(order * jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1)), axis=-1)\n\n\nclass ExpTransform(Transform):\n # TODO: refine domain/codomain logic through setters, especially when\n # transforms for inverses are supported\n def __init__(self, domain=constraints.real):\n self.domain = domain\n\n @property\n def codomain(self):\n if self.domain is constraints.real:\n return constraints.positive\n elif isinstance(self.domain, constraints.greater_than):\n return constraints.greater_than(self.__call__(self.domain.lower_bound))\n elif isinstance(self.domain, constraints.interval):\n return constraints.interval(self.__call__(self.domain.lower_bound),\n self.__call__(self.domain.upper_bound))\n else:\n raise NotImplementedError\n\n def __call__(self, x):\n # XXX consider to clamp from below for stability if necessary\n return jnp.exp(x)\n\n def _inverse(self, y):\n return jnp.log(y)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n return x\n\n\nclass IdentityTransform(Transform):\n\n def __call__(self, x):\n return x\n\n def _inverse(self, y):\n return y\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n return jnp.zeros_like(x)\n\n\nclass IndependentTransform(Transform):\n \"\"\"\n Wraps a transform by aggregating over ``reinterpreted_batch_ndims``-many\n dims in :meth:`check`, so that an event is valid only if all its\n independent entries are valid.\n \"\"\"\n def __init__(self, base_transform, reinterpreted_batch_ndims):\n assert isinstance(base_transform, Transform)\n assert isinstance(reinterpreted_batch_ndims, int)\n assert reinterpreted_batch_ndims >= 0\n self.base_transform = base_transform\n self.reinterpreted_batch_ndims = reinterpreted_batch_ndims\n super().__init__()\n\n @property\n def domain(self):\n return constraints.independent(self.base_transform.domain, self.reinterpreted_batch_ndims)\n\n @property\n def codomain(self):\n return constraints.independent(self.base_transform.codomain, self.reinterpreted_batch_ndims)\n\n def __call__(self, x):\n return self.base_transform(x)\n\n def _inverse(self, y):\n return self.base_transform._inverse(y)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n result = self.base_transform.log_abs_det_jacobian(x, y, intermediates=intermediates)\n if jnp.ndim(result) < self.reinterpreted_batch_ndims:\n expected = self.domain.event_dim\n raise ValueError(f\"Expected x.dim() >= {expected} but got {jnp.ndim(x)}\")\n return sum_rightmost(result, self.reinterpreted_batch_ndims)\n\n def call_with_intermediates(self, x):\n return self.base_transform.call_with_intermediates(x)\n\n def forward_shape(self, shape):\n return self.base_transform.forward_shape(shape)\n\n def inverse_shape(self, shape):\n return self.base_transform.inverse_shape(shape)\n\n\nclass InvCholeskyTransform(Transform):\n r\"\"\"\n Transform via the mapping :math:`y = x @ x.T`, where `x` is a lower\n triangular matrix with positive diagonal.\n \"\"\"\n\n def __init__(self, domain=constraints.lower_cholesky):\n warnings.warn(\"InvCholeskyTransform is deprecated. Please use CholeskyTransform\"\n \" or CorrMatrixCholeskyTransform instead.\", FutureWarning)\n assert domain in [constraints.lower_cholesky, constraints.corr_cholesky]\n self.domain = domain\n\n @property\n def codomain(self):\n if self.domain is constraints.lower_cholesky:\n return constraints.positive_definite\n elif self.domain is constraints.corr_cholesky:\n return constraints.corr_matrix\n\n def __call__(self, x):\n return jnp.matmul(x, jnp.swapaxes(x, -2, -1))\n\n def _inverse(self, y):\n return jnp.linalg.cholesky(y)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n if self.domain is constraints.lower_cholesky:\n # Ref: http://web.mit.edu/18.325/www/handouts/handout2.pdf page 13\n n = jnp.shape(x)[-1]\n order = jnp.arange(n, 0, -1)\n return n * jnp.log(2) + jnp.sum(order * jnp.log(jnp.diagonal(x, axis1=-2, axis2=-1)), axis=-1)\n else:\n # NB: see derivation in LKJCholesky implementation\n n = jnp.shape(x)[-1]\n order = jnp.arange(n - 1, -1, -1)\n return jnp.sum(order * jnp.log(jnp.diagonal(x, axis1=-2, axis2=-1)), axis=-1)\n\n\nclass LowerCholeskyAffine(Transform):\n r\"\"\"\n Transform via the mapping :math:`y = loc + scale\\_tril\\ @\\ x`.\n\n :param loc: a real vector.\n :param scale_tril: a lower triangular matrix with positive diagonal.\n \"\"\"\n domain = constraints.real_vector\n codomain = constraints.real_vector\n\n def __init__(self, loc, scale_tril):\n if jnp.ndim(scale_tril) != 2:\n raise ValueError(\"Only support 2-dimensional scale_tril matrix. \"\n \"Please make a feature request if you need to \"\n \"use this transform with batched scale_tril.\")\n self.loc = loc\n self.scale_tril = scale_tril\n\n def __call__(self, x):\n return self.loc + jnp.squeeze(jnp.matmul(self.scale_tril, x[..., jnp.newaxis]), axis=-1)\n\n def _inverse(self, y):\n y = y - self.loc\n original_shape = jnp.shape(y)\n yt = jnp.reshape(y, (-1, original_shape[-1])).T\n xt = solve_triangular(self.scale_tril, yt, lower=True)\n return jnp.reshape(xt.T, original_shape)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n return jnp.broadcast_to(jnp.log(jnp.diagonal(self.scale_tril, axis1=-2, axis2=-1)).sum(-1),\n jnp.shape(x)[:-1])\n\n def forward_shape(self, shape):\n if len(shape) < 1:\n raise ValueError(\"Too few dimensions on input\")\n return lax.broadcast_shapes(shape, self.loc.shape, self.scale_tril.shape[:-1])\n\n def inverse_shape(self, shape):\n if len(shape) < 1:\n raise ValueError(\"Too few dimensions on input\")\n return lax.broadcast_shapes(shape, self.loc.shape, self.scale_tril.shape[:-1])\n\n\nclass LowerCholeskyTransform(Transform):\n domain = constraints.real_vector\n codomain = constraints.lower_cholesky\n\n def __call__(self, x):\n n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2)\n z = vec_to_tril_matrix(x[..., :-n], diagonal=-1)\n diag = jnp.exp(x[..., -n:])\n return z + jnp.expand_dims(diag, axis=-1) * jnp.identity(n)\n\n def _inverse(self, y):\n z = matrix_to_tril_vec(y, diagonal=-1)\n return jnp.concatenate([z, jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1))], axis=-1)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n # the jacobian is diagonal, so logdet is the sum of diagonal `exp` transform\n n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2)\n return x[..., -n:].sum(-1)\n\n def forward_shape(self, shape):\n return _matrix_forward_shape(shape)\n\n def inverse_shape(self, shape):\n return _matrix_inverse_shape(shape)\n\n\nclass OrderedTransform(Transform):\n \"\"\"\n Transform a real vector to an ordered vector.\n\n **References:**\n\n 1. *Stan Reference Manual v2.20, section 10.6*,\n Stan Development Team\n \"\"\"\n domain = constraints.real_vector\n codomain = constraints.ordered_vector\n\n def __call__(self, x):\n z = jnp.concatenate([x[..., :1], jnp.exp(x[..., 1:])], axis=-1)\n return jnp.cumsum(z, axis=-1)\n\n def _inverse(self, y):\n x = jnp.log(y[..., 1:] - y[..., :-1])\n return jnp.concatenate([y[..., :1], x], axis=-1)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n return jnp.sum(x[..., 1:], -1)\n\n\nclass PermuteTransform(Transform):\n domain = constraints.real_vector\n codomain = constraints.real_vector\n\n def __init__(self, permutation):\n self.permutation = permutation\n\n def __call__(self, x):\n return x[..., self.permutation]\n\n def _inverse(self, y):\n size = self.permutation.size\n permutation_inv = ops.index_update(jnp.zeros(size, dtype=jnp.result_type(int)),\n self.permutation,\n jnp.arange(size))\n return y[..., permutation_inv]\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n return jnp.full(jnp.shape(x)[:-1], 0.)\n\n\nclass PowerTransform(Transform):\n domain = constraints.positive\n codomain = constraints.positive\n\n def __init__(self, exponent):\n self.exponent = exponent\n\n def __call__(self, x):\n return jnp.power(x, self.exponent)\n\n def _inverse(self, y):\n return jnp.power(y, 1 / self.exponent)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n return jnp.log(jnp.abs(self.exponent * y / x))\n\n def forward_shape(self, shape):\n return lax.broadcast_shapes(shape, getattr(self.exponent, \"shape\", ()))\n\n def inverse_shape(self, shape):\n return lax.broadcast_shapes(shape, getattr(self.exponent, \"shape\", ()))\n\n\nclass SigmoidTransform(Transform):\n codomain = constraints.unit_interval\n\n def __call__(self, x):\n return _clipped_expit(x)\n\n def _inverse(self, y):\n return logit(y)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n x_abs = jnp.abs(x)\n return -x_abs - 2 * jnp.log1p(jnp.exp(-x_abs))\n\n\ndef _softplus_inv(y):\n return jnp.log(-jnp.expm1(-y)) + y\n\n\nclass SoftplusTransform(Transform):\n r\"\"\"\n Transform from unconstrained space to positive domain via softplus :math:`y = \\log(1 + \\exp(x))`.\n The inverse is computed as :math:`x = \\log(\\exp(y) - 1)`.\n \"\"\"\n domain = constraints.real\n codomain = constraints.softplus_positive\n\n def __call__(self, x):\n return softplus(x)\n\n def _inverse(self, y):\n return _softplus_inv(y)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n return -softplus(-x)\n\n\nclass SoftplusLowerCholeskyTransform(Transform):\n \"\"\"\n Transform from unconstrained vector to lower-triangular matrices with\n nonnegative diagonal entries. This is useful for parameterizing positive\n definite matrices in terms of their Cholesky factorization.\n \"\"\"\n domain = constraints.real_vector\n codomain = constraints.softplus_lower_cholesky\n\n def __call__(self, x):\n n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2)\n z = vec_to_tril_matrix(x[..., :-n], diagonal=-1)\n diag = softplus(x[..., -n:])\n return z + jnp.expand_dims(diag, axis=-1) * jnp.identity(n)\n\n def _inverse(self, y):\n z = matrix_to_tril_vec(y, diagonal=-1)\n diag = _softplus_inv(jnp.diagonal(y, axis1=-2, axis2=-1))\n return jnp.concatenate([z, diag], axis=-1)\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n # the jacobian is diagonal, so logdet is the sum of diagonal `exp` transform\n n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2)\n return -softplus(-x[..., -n:]).sum(-1)\n\n def forward_shape(self, shape):\n return _matrix_forward_shape(shape)\n\n def inverse_shape(self, shape):\n return _matrix_inverse_shape(shape)\n\n\nclass StickBreakingTransform(Transform):\n domain = constraints.real_vector\n codomain = constraints.simplex\n\n def __call__(self, x):\n # we shift x to obtain a balanced mapping (0, 0, ..., 0) -> (1/K, 1/K, ..., 1/K)\n x = x - jnp.log(x.shape[-1] - jnp.arange(x.shape[-1]))\n # convert to probabilities (relative to the remaining) of each fraction of the stick\n z = _clipped_expit(x)\n z1m_cumprod = jnp.cumprod(1 - z, axis=-1)\n pad_width = [(0, 0)] * x.ndim\n pad_width[-1] = (0, 1)\n z_padded = jnp.pad(z, pad_width, mode=\"constant\", constant_values=1.)\n pad_width = [(0, 0)] * x.ndim\n pad_width[-1] = (1, 0)\n z1m_cumprod_shifted = jnp.pad(z1m_cumprod, pad_width, mode=\"constant\", constant_values=1.)\n return z_padded * z1m_cumprod_shifted\n\n def _inverse(self, y):\n y_crop = y[..., :-1]\n z1m_cumprod = jnp.clip(1 - jnp.cumsum(y_crop, axis=-1), a_min=jnp.finfo(y.dtype).tiny)\n # hence x = logit(z) = log(z / (1 - z)) = y[::-1] / z1m_cumprod\n x = jnp.log(y_crop / z1m_cumprod)\n return x + jnp.log(x.shape[-1] - jnp.arange(x.shape[-1]))\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n # Ref: https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html\n # |det|(J) = Product(y * (1 - z))\n x = x - jnp.log(x.shape[-1] - jnp.arange(x.shape[-1]))\n z = jnp.clip(expit(x), a_min=jnp.finfo(x.dtype).tiny)\n # XXX we use the identity 1 - z = z * exp(-x) to not worry about\n # the case z ~ 1\n return jnp.sum(jnp.log(y[..., :-1] * z) - x, axis=-1)\n\n def forward_shape(self, shape):\n if len(shape) < 1:\n raise ValueError(\"Too few dimensions on input\")\n return shape[:-1] + (shape[-1] + 1,)\n\n def inverse_shape(self, shape):\n if len(shape) < 1:\n raise ValueError(\"Too few dimensions on input\")\n return shape[:-1] + (shape[-1] - 1,)\n\n\nclass UnpackTransform(Transform):\n \"\"\"\n Transforms a contiguous array to a pytree of subarrays.\n\n :param unpack_fn: callable used to unpack a contiguous array.\n \"\"\"\n domain = constraints.real_vector\n codomain = constraints.dependent\n\n def __init__(self, unpack_fn):\n self.unpack_fn = unpack_fn\n\n def __call__(self, x):\n batch_shape = x.shape[:-1]\n if batch_shape:\n unpacked = vmap(self.unpack_fn)(x.reshape((-1,) + x.shape[-1:]))\n return tree_map(lambda z: jnp.reshape(z, batch_shape + z.shape[1:]), unpacked)\n else:\n return self.unpack_fn(x)\n\n def _inverse(self, y):\n leading_dims = [v.shape[0] if jnp.ndim(v) > 0 else 0\n for v in tree_flatten(y)[0]]\n d0 = leading_dims[0]\n not_scalar = d0 > 0 or len(leading_dims) > 1\n if not_scalar and all(d == d0 for d in leading_dims[1:]):\n warnings.warn(\"UnpackTransform.inv might lead to an unexpected behavior because it\"\n \" cannot transform a batch of unpacked arrays.\")\n return ravel_pytree(y)[0]\n\n def log_abs_det_jacobian(self, x, y, intermediates=None):\n return jnp.zeros(jnp.shape(x)[:-1])\n\n def forward_shape(self, shape):\n raise NotImplementedError\n\n def inverse_shape(self, shape):\n raise NotImplementedError\n\n\n##########################################################\n# CONSTRAINT_REGISTRY\n##########################################################\n\nclass ConstraintRegistry(object):\n def __init__(self):\n self._registry = {}\n\n def register(self, constraint, factory=None):\n if factory is None:\n return lambda factory: self.register(constraint, factory)\n\n if isinstance(constraint, constraints.Constraint):\n constraint = type(constraint)\n\n self._registry[constraint] = factory\n\n def __call__(self, constraint):\n try:\n factory = self._registry[type(constraint)]\n except KeyError as e:\n raise NotImplementedError from e\n\n return factory(constraint)\n\n\nbiject_to = ConstraintRegistry()\n\n\n@biject_to.register(constraints.corr_cholesky)\ndef _transform_to_corr_cholesky(constraint):\n return CorrCholeskyTransform()\n\n\n@biject_to.register(constraints.corr_matrix)\ndef _transform_to_corr_matrix(constraint):\n return ComposeTransform([CorrCholeskyTransform(),\n CorrMatrixCholeskyTransform().inv])\n\n\n@biject_to.register(constraints.greater_than)\ndef _transform_to_greater_than(constraint):\n if constraint is constraints.positive:\n return ExpTransform()\n return ComposeTransform([ExpTransform(),\n AffineTransform(constraint.lower_bound, 1,\n domain=constraints.positive)])\n\n\n@biject_to.register(constraints.less_than)\ndef _transform_to_less_than(constraint):\n return ComposeTransform([ExpTransform(),\n AffineTransform(constraint.upper_bound, -1,\n domain=constraints.positive)])\n\n\n@biject_to.register(constraints.independent)\ndef _biject_to_independent(constraint):\n return IndependentTransform(biject_to(constraint.base_constraint),\n constraint.reinterpreted_batch_ndims)\n\n\n@biject_to.register(constraints.interval)\ndef _transform_to_interval(constraint):\n if constraint is constraints.unit_interval:\n return SigmoidTransform()\n scale = constraint.upper_bound - constraint.lower_bound\n return ComposeTransform([SigmoidTransform(),\n AffineTransform(constraint.lower_bound, scale,\n domain=constraints.unit_interval)])\n\n\n@biject_to.register(constraints.lower_cholesky)\ndef _transform_to_lower_cholesky(constraint):\n return LowerCholeskyTransform()\n\n\n@biject_to.register(constraints.ordered_vector)\ndef _transform_to_ordered_vector(constraint):\n return OrderedTransform()\n\n\n@biject_to.register(constraints.positive_definite)\ndef _transform_to_positive_definite(constraint):\n return ComposeTransform([LowerCholeskyTransform(), CholeskyTransform().inv])\n\n\n@biject_to.register(constraints.positive_ordered_vector)\ndef _transform_to_positive_ordered_vector(constraint):\n return ComposeTransform([OrderedTransform(), ExpTransform()])\n\n\n@biject_to.register(constraints.real)\ndef _transform_to_real(constraint):\n return IdentityTransform()\n\n\n@biject_to.register(constraints.softplus_positive)\ndef _transform_to_softplus_positive(constraint):\n return SoftplusTransform()\n\n\n@biject_to.register(constraints.softplus_lower_cholesky)\ndef _transform_to_softplus_lower_cholesky(constraint):\n return SoftplusLowerCholeskyTransform()\n\n\n@biject_to.register(constraints.simplex)\ndef _transform_to_simplex(constraint):\n return StickBreakingTransform()\n",
"# Copyright Contributors to the Pyro project.\n# SPDX-License-Identifier: Apache-2.0\n\nfrom collections import namedtuple\nfrom functools import update_wrapper\nimport math\n\nimport numpy as np\n\nfrom jax import jit, lax, random, vmap\nfrom jax.lib import xla_bridge\nimport jax.numpy as jnp\nfrom jax.scipy.linalg import solve_triangular\nfrom jax.util import partial\n\n# Parameters for Transformed Rejection with Squeeze (TRS) algorithm - page 3.\n_tr_params = namedtuple('tr_params', ['c', 'b', 'a', 'alpha', 'u_r', 'v_r', 'm', 'log_p', 'log1_p', 'log_h'])\n\n\ndef _get_tr_params(n, p):\n # See Table 1. Additionally, we pre-compute log(p), log1(-p) and the\n # constant terms, that depend only on (n, p, m) in log(f(k)) (bottom of page 5).\n mu = n * p\n spq = jnp.sqrt(mu * (1 - p))\n c = mu + 0.5\n b = 1.15 + 2.53 * spq\n a = -0.0873 + 0.0248 * b + 0.01 * p\n alpha = (2.83 + 5.1 / b) * spq\n u_r = 0.43\n v_r = 0.92 - 4.2 / b\n m = jnp.floor((n + 1) * p).astype(n.dtype)\n log_p = jnp.log(p)\n log1_p = jnp.log1p(-p)\n log_h = (m + 0.5) * (jnp.log((m + 1.) / (n - m + 1.)) + log1_p - log_p) + \\\n (stirling_approx_tail(m) + stirling_approx_tail(n - m))\n return _tr_params(c, b, a, alpha, u_r, v_r, m, log_p, log1_p, log_h)\n\n\ndef stirling_approx_tail(k):\n precomputed = jnp.array([\n 0.08106146679532726,\n 0.04134069595540929,\n 0.02767792568499834,\n 0.02079067210376509,\n 0.01664469118982119,\n 0.01387612882307075,\n 0.01189670994589177,\n 0.01041126526197209,\n 0.009255462182712733,\n 0.008330563433362871,\n ])\n kp1 = k + 1\n kp1sq = (k + 1) ** 2\n return jnp.where(k < 10,\n precomputed[k],\n (1. / 12 - (1. / 360 - (1. / 1260) / kp1sq) / kp1sq) / kp1)\n\n\ndef _binomial_btrs(key, p, n):\n \"\"\"\n Based on the transformed rejection sampling algorithm (BTRS) from the\n following reference:\n\n Hormann, \"The Generation of Binonmial Random Variates\"\n (https://core.ac.uk/download/pdf/11007254.pdf)\n \"\"\"\n\n def _btrs_body_fn(val):\n _, key, _, _ = val\n key, key_u, key_v = random.split(key, 3)\n u = random.uniform(key_u)\n v = random.uniform(key_v)\n u = u - 0.5\n k = jnp.floor((2 * tr_params.a / (0.5 - jnp.abs(u)) + tr_params.b) * u + tr_params.c).astype(n.dtype)\n return k, key, u, v\n\n def _btrs_cond_fn(val):\n def accept_fn(k, u, v):\n # See acceptance condition in Step 3. (Page 3) of TRS algorithm\n # v <= f(k) * g_grad(u) / alpha\n\n m = tr_params.m\n log_p = tr_params.log_p\n log1_p = tr_params.log1_p\n # See: formula for log(f(k)) at bottom of Page 5.\n log_f = (n + 1.) * jnp.log((n - m + 1.) / (n - k + 1.)) + \\\n (k + 0.5) * (jnp.log((n - k + 1.) / (k + 1.)) + log_p - log1_p) + \\\n (stirling_approx_tail(k) - stirling_approx_tail(n - k)) + tr_params.log_h\n g = (tr_params.a / (0.5 - jnp.abs(u)) ** 2) + tr_params.b\n return jnp.log((v * tr_params.alpha) / g) <= log_f\n\n k, key, u, v = val\n early_accept = (jnp.abs(u) <= tr_params.u_r) & (v <= tr_params.v_r)\n early_reject = (k < 0) | (k > n)\n return lax.cond(early_accept | early_reject,\n (),\n lambda _: ~early_accept,\n (k, u, v),\n lambda x: ~accept_fn(*x))\n\n tr_params = _get_tr_params(n, p)\n ret = lax.while_loop(_btrs_cond_fn, _btrs_body_fn,\n (-1, key, 1., 1.)) # use k=-1 initially so that cond_fn returns True\n return ret[0]\n\n\ndef _binomial_inversion(key, p, n):\n def _binom_inv_body_fn(val):\n i, key, geom_acc = val\n key, key_u = random.split(key)\n u = random.uniform(key_u)\n geom = jnp.floor(jnp.log1p(-u) / log1_p) + 1\n geom_acc = geom_acc + geom\n return i + 1, key, geom_acc\n\n def _binom_inv_cond_fn(val):\n i, _, geom_acc = val\n return geom_acc <= n\n\n log1_p = jnp.log1p(-p)\n ret = lax.while_loop(_binom_inv_cond_fn, _binom_inv_body_fn,\n (-1, key, 0.))\n return ret[0]\n\n\ndef _binomial_dispatch(key, p, n):\n def dispatch(key, p, n):\n is_le_mid = p <= 0.5\n pq = jnp.where(is_le_mid, p, 1 - p)\n mu = n * pq\n k = lax.cond(mu < 10,\n (key, pq, n),\n lambda x: _binomial_inversion(*x),\n (key, pq, n),\n lambda x: _binomial_btrs(*x))\n return jnp.where(is_le_mid, k, n - k)\n\n # Return 0 for nan `p` or negative `n`, since nan values are not allowed for integer types\n cond0 = jnp.isfinite(p) & (n > 0) & (p > 0)\n return lax.cond(cond0 & (p < 1),\n (key, p, n),\n lambda x: dispatch(*x),\n (),\n lambda _: jnp.where(cond0, n, 0))\n\n\n@partial(jit, static_argnums=(3,))\ndef _binomial(key, p, n, shape):\n shape = shape or lax.broadcast_shapes(jnp.shape(p), jnp.shape(n))\n # reshape to map over axis 0\n p = jnp.reshape(jnp.broadcast_to(p, shape), -1)\n n = jnp.reshape(jnp.broadcast_to(n, shape), -1)\n key = random.split(key, jnp.size(p))\n if xla_bridge.get_backend().platform == 'cpu':\n ret = lax.map(lambda x: _binomial_dispatch(*x),\n (key, p, n))\n else:\n ret = vmap(lambda *x: _binomial_dispatch(*x))(key, p, n)\n return jnp.reshape(ret, shape)\n\n\ndef binomial(key, p, n=1, shape=()):\n return _binomial(key, p, n, shape)\n\n\n@partial(jit, static_argnums=(2,))\ndef _categorical(key, p, shape):\n # this implementation is fast when event shape is small, and slow otherwise\n # Ref: https://stackoverflow.com/a/34190035\n shape = shape or p.shape[:-1]\n s = jnp.cumsum(p, axis=-1)\n r = random.uniform(key, shape=shape + (1,))\n # FIXME: replace this computation by using binary search as suggested in the above\n # reference. A while_loop + vmap for a reshaped 2D array would be enough.\n return jnp.sum(s < r, axis=-1)\n\n\ndef categorical(key, p, shape=()):\n return _categorical(key, p, shape)\n\n\ndef _scatter_add_one(operand, indices, updates):\n return lax.scatter_add(operand, indices, updates,\n lax.ScatterDimensionNumbers(update_window_dims=(),\n inserted_window_dims=(0,),\n scatter_dims_to_operand_dims=(0,)))\n\n\n@partial(jit, static_argnums=(3, 4))\ndef _multinomial(key, p, n, n_max, shape=()):\n if jnp.shape(n) != jnp.shape(p)[:-1]:\n broadcast_shape = lax.broadcast_shapes(jnp.shape(n), jnp.shape(p)[:-1])\n n = jnp.broadcast_to(n, broadcast_shape)\n p = jnp.broadcast_to(p, broadcast_shape + jnp.shape(p)[-1:])\n shape = shape or p.shape[:-1]\n # get indices from categorical distribution then gather the result\n indices = categorical(key, p, (n_max,) + shape)\n # mask out values when counts is heterogeneous\n if jnp.ndim(n) > 0:\n mask = promote_shapes(jnp.arange(n_max) < jnp.expand_dims(n, -1), shape=shape + (n_max,))[0]\n mask = jnp.moveaxis(mask, -1, 0).astype(indices.dtype)\n excess = jnp.concatenate([jnp.expand_dims(n_max - n, -1), jnp.zeros(jnp.shape(n) + (p.shape[-1] - 1,))], -1)\n else:\n mask = 1\n excess = 0\n # NB: we transpose to move batch shape to the front\n indices_2D = (jnp.reshape(indices * mask, (n_max, -1,))).T\n samples_2D = vmap(_scatter_add_one, (0, 0, 0))(jnp.zeros((indices_2D.shape[0], p.shape[-1]),\n dtype=indices.dtype),\n jnp.expand_dims(indices_2D, axis=-1),\n jnp.ones(indices_2D.shape, dtype=indices.dtype))\n return jnp.reshape(samples_2D, shape + p.shape[-1:]) - excess\n\n\ndef multinomial(key, p, n, shape=()):\n n_max = int(jnp.max(n))\n return _multinomial(key, p, n, n_max, shape)\n\n\ndef cholesky_of_inverse(matrix):\n # This formulation only takes the inverse of a triangular matrix\n # which is more numerically stable.\n # Refer to:\n # https://nbviewer.jupyter.org/gist/fehiepsi/5ef8e09e61604f10607380467eb82006#Precision-to-scale_tril\n tril_inv = jnp.swapaxes(jnp.linalg.cholesky(matrix[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1)\n identity = jnp.broadcast_to(jnp.identity(matrix.shape[-1]), tril_inv.shape)\n return solve_triangular(tril_inv, identity, lower=True)\n\n\n# TODO: move upstream to jax.nn\ndef binary_cross_entropy_with_logits(x, y):\n # compute -y * log(sigmoid(x)) - (1 - y) * log(1 - sigmoid(x))\n # Ref: https://www.tensorflow.org/api_docs/python/tf/nn/sigmoid_cross_entropy_with_logits\n return jnp.clip(x, 0) + jnp.log1p(jnp.exp(-jnp.abs(x))) - x * y\n\n\ndef _reshape(x, shape):\n if isinstance(x, (int, float, np.ndarray, np.generic)):\n return np.reshape(x, shape)\n else:\n return jnp.reshape(x, shape)\n\n\ndef promote_shapes(*args, shape=()):\n # adapted from lax.lax_numpy\n if len(args) < 2 and not shape:\n return args\n else:\n shapes = [jnp.shape(arg) for arg in args]\n num_dims = len(lax.broadcast_shapes(shape, *shapes))\n return [_reshape(arg, (1,) * (num_dims - len(s)) + s)\n if len(s) < num_dims else arg for arg, s in zip(args, shapes)]\n\n\ndef sum_rightmost(x, dim):\n \"\"\"\n Sum out ``dim`` many rightmost dimensions of a given tensor.\n \"\"\"\n out_dim = jnp.ndim(x) - dim\n x = jnp.reshape(jnp.expand_dims(x, -1), jnp.shape(x)[:out_dim] + (-1,))\n return jnp.sum(x, axis=-1)\n\n\ndef matrix_to_tril_vec(x, diagonal=0):\n idxs = jnp.tril_indices(x.shape[-1], diagonal)\n return x[..., idxs[0], idxs[1]]\n\n\ndef vec_to_tril_matrix(t, diagonal=0):\n # NB: the following formula only works for diagonal <= 0\n n = round((math.sqrt(1 + 8 * t.shape[-1]) - 1) / 2) - diagonal\n n2 = n * n\n idx = jnp.reshape(jnp.arange(n2), (n, n))[jnp.tril_indices(n, diagonal)]\n x = lax.scatter_add(jnp.zeros(t.shape[:-1] + (n2,)), jnp.expand_dims(idx, axis=-1), t,\n lax.ScatterDimensionNumbers(update_window_dims=range(t.ndim - 1),\n inserted_window_dims=(t.ndim - 1,),\n scatter_dims_to_operand_dims=(t.ndim - 1,)))\n return jnp.reshape(x, x.shape[:-1] + (n, n))\n\n\ndef cholesky_update(L, x, coef=1):\n \"\"\"\n Finds cholesky of L @ L.T + coef * x @ x.T.\n\n **References;**\n\n 1. A more efficient rank-one covariance matrix update for evolution strategies,\n Oswin Krause and Christian Igel\n \"\"\"\n batch_shape = lax.broadcast_shapes(L.shape[:-2], x.shape[:-1])\n L = jnp.broadcast_to(L, batch_shape + L.shape[-2:])\n x = jnp.broadcast_to(x, batch_shape + x.shape[-1:])\n diag = jnp.diagonal(L, axis1=-2, axis2=-1)\n # convert to unit diagonal triangular matrix: L @ D @ T.t\n L = L / diag[..., None, :]\n D = jnp.square(diag)\n\n def scan_fn(carry, val):\n b, w = carry\n j, Dj, L_j = val\n wj = w[..., j]\n gamma = b * Dj + coef * jnp.square(wj)\n Dj_new = gamma / b\n b = gamma / Dj_new\n\n # update vectors w and L_j\n w = w - wj[..., None] * L_j\n L_j = L_j + (coef * wj / gamma)[..., None] * w\n return (b, w), (Dj_new, L_j)\n\n D, L = jnp.moveaxis(D, -1, 0), jnp.moveaxis(L, -1, 0) # move scan dim to front\n _, (D, L) = lax.scan(scan_fn, (jnp.ones(batch_shape), x), (jnp.arange(D.shape[0]), D, L))\n D, L = jnp.moveaxis(D, 0, -1), jnp.moveaxis(L, 0, -1) # move scan dim back\n return L * jnp.sqrt(D)[..., None, :]\n\n\ndef signed_stick_breaking_tril(t):\n # make sure that t in (-1, 1)\n eps = jnp.finfo(t.dtype).eps\n t = jnp.clip(t, a_min=(-1 + eps), a_max=(1 - eps))\n # transform t to tril matrix with identity diagonal\n r = vec_to_tril_matrix(t, diagonal=-1)\n\n # apply stick-breaking on the squared values;\n # we omit the step of computing s = z * z_cumprod by using the fact:\n # y = sign(r) * s = sign(r) * sqrt(z * z_cumprod) = r * sqrt(z_cumprod)\n z = r ** 2\n z1m_cumprod_sqrt = jnp.cumprod(jnp.sqrt(1 - z), axis=-1)\n\n pad_width = [(0, 0)] * z.ndim\n pad_width[-1] = (1, 0)\n z1m_cumprod_sqrt_shifted = jnp.pad(z1m_cumprod_sqrt[..., :-1], pad_width,\n mode=\"constant\", constant_values=1.)\n y = (r + jnp.identity(r.shape[-1])) * z1m_cumprod_sqrt_shifted\n return y\n\n\ndef logmatmulexp(x, y):\n \"\"\"\n Numerically stable version of ``(x.log() @ y.log()).exp()``.\n \"\"\"\n x_shift = lax.stop_gradient(jnp.amax(x, -1, keepdims=True))\n y_shift = lax.stop_gradient(jnp.amax(y, -2, keepdims=True))\n xy = jnp.log(jnp.matmul(jnp.exp(x - x_shift), jnp.exp(y - y_shift)))\n return xy + x_shift + y_shift\n\n\ndef clamp_probs(probs):\n finfo = jnp.finfo(jnp.result_type(probs))\n return jnp.clip(probs, a_min=finfo.tiny, a_max=1. - finfo.eps)\n\n\ndef is_identically_zero(x):\n \"\"\"\n Check if argument is exactly the number zero. True for the number zero;\n false for other numbers; false for ndarrays.\n \"\"\"\n if isinstance(x, (int, float)):\n return x == 0\n else:\n return False\n\n\ndef is_identically_one(x):\n \"\"\"\n Check if argument is exactly the number one. True for the number one;\n false for other numbers; false for ndarrays.\n \"\"\"\n if isinstance(x, (int, float)):\n return x == 1\n else:\n return False\n\n\ndef von_mises_centered(key, concentration, shape=(), dtype=jnp.float64):\n \"\"\" Compute centered von Mises samples using rejection sampling from [1] with wrapped Cauchy proposal.\n\n *** References ***\n [1] Luc Devroye \"Non-Uniform Random Variate Generation\", Springer-Verlag, 1986;\n Chapter 9, p. 473-476. http://www.nrbook.com/devroye/Devroye_files/chapter_nine.pdf\n\n\n :param key: random number generator key\n :param concentration: concentration of distribution\n :param shape: shape of samples\n :param dtype: float precesions for choosing correct s cutfoff\n :return: centered samples from von Mises\n \"\"\"\n shape = shape or jnp.shape(concentration)\n dtype = jnp.result_type(dtype)\n concentration = lax.convert_element_type(concentration, dtype)\n concentration = jnp.broadcast_to(concentration, shape)\n return _von_mises_centered(key, concentration, shape, dtype)\n\n\n@partial(jit, static_argnums=(2, 3))\ndef _von_mises_centered(key, concentration, shape, dtype):\n # Cutoff from TensorFlow probability\n # (https://github.com/tensorflow/probability/blob/f051e03dd3cc847d31061803c2b31c564562a993/tensorflow_probability/python/distributions/von_mises.py#L567-L570)\n s_cutoff_map = {jnp.dtype(jnp.float16): 1.8e-1,\n jnp.dtype(jnp.float32): 2e-2,\n jnp.dtype(jnp.float64): 1.2e-4}\n s_cutoff = s_cutoff_map.get(dtype)\n\n r = 1. + jnp.sqrt(1. + 4. * concentration ** 2)\n rho = (r - jnp.sqrt(2. * r)) / (2. * concentration)\n s_exact = (1. + rho ** 2) / (2. * rho)\n\n s_approximate = 1. / concentration\n\n s = jnp.where(concentration > s_cutoff, s_exact, s_approximate)\n\n def cond_fn(*args):\n \"\"\" check if all are done or reached max number of iterations \"\"\"\n i, _, done, _, _ = args[0]\n return jnp.bitwise_and(i < 100, jnp.logical_not(jnp.all(done)))\n\n def body_fn(*args):\n i, key, done, _, w = args[0]\n uni_ukey, uni_vkey, key = random.split(key, 3)\n\n u = random.uniform(key=uni_ukey, shape=shape, dtype=concentration.dtype, minval=-1., maxval=1.)\n z = jnp.cos(jnp.pi * u)\n w = jnp.where(done, w, (1. + s * z) / (s + z)) # Update where not done\n\n y = concentration * (s - w)\n v = random.uniform(key=uni_vkey, shape=shape, dtype=concentration.dtype)\n\n accept = (y * (2. - y) >= v) | (jnp.log(y / v) + 1. >= y)\n\n return i+1, key, accept | done, u, w\n\n init_done = jnp.zeros(shape, dtype=bool)\n init_u = jnp.zeros(shape)\n init_w = jnp.zeros(shape)\n\n _, _, done, u, w = lax.while_loop(\n cond_fun=cond_fn,\n body_fun=body_fn,\n init_val=(jnp.array(0), key, init_done, init_u, init_w)\n )\n\n return jnp.sign(u) * jnp.arccos(w)\n\n\ndef scale_and_mask(x, scale=None, mask=None):\n \"\"\"\n Scale and mask a tensor, broadcasting and avoiding unnecessary ops.\n \"\"\"\n if is_identically_zero(x):\n return x\n if not (scale is None or is_identically_one(scale)):\n x = x * scale\n if mask is None:\n return x\n else:\n return jnp.where(mask, x, 0.)\n\n\n# TODO: use funsor implementation\ndef periodic_repeat(x, size, dim):\n \"\"\"\n Repeat a ``period``-sized array up to given ``size``.\n \"\"\"\n assert isinstance(size, int) and size >= 0\n assert isinstance(dim, int)\n if dim >= 0:\n dim -= jnp.ndim(x)\n\n period = jnp.shape(x)[dim]\n repeats = (size + period - 1) // period\n result = jnp.repeat(x, repeats, axis=dim)\n result = result[(Ellipsis, slice(None, size)) + (slice(None),) * (-1 - dim)]\n return result\n\n\ndef safe_normalize(x, *, p=2):\n \"\"\"\n Safely project a vector onto the sphere wrt the ``p``-norm. This avoids the\n singularity at zero by mapping zero to the uniform unit vector proportional\n to ``[1, 1, ..., 1]``.\n\n :param numpy.ndarray x: A vector\n :param float p: The norm exponent, defaults to 2 i.e. the Euclidean norm.\n :returns: A normalized version ``x / ||x||_p``.\n :rtype: numpy.ndarray\n \"\"\"\n assert isinstance(p, (float, int))\n assert p >= 0\n norm = jnp.linalg.norm(x, p, axis=-1, keepdims=True)\n x = x / jnp.clip(norm, a_min=jnp.finfo(x).tiny)\n # Avoid the singularity.\n mask = jnp.all(x == 0, axis=-1, keepdims=True)\n x = jnp.where(mask, x.shape[-1] ** (-1/p), x)\n return x\n\n\n# src: https://github.com/google/jax/blob/5a41779fbe12ba7213cd3aa1169d3b0ffb02a094/jax/_src/random.py#L95\ndef is_prng_key(key):\n try:\n return key.shape == (2,) and key.dtype == np.uint32\n except AttributeError:\n return False\n\n\n# The is sourced from: torch.distributions.util.py\n#\n# Copyright (c) 2016- Facebook, Inc (Adam Paszke)\n# Copyright (c) 2014- Facebook, Inc (Soumith Chintala)\n# Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert)\n# Copyright (c) 2012-2014 Deepmind Technologies (Koray Kavukcuoglu)\n# Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu)\n# Copyright (c) 2011-2013 NYU (Clement Farabet)\n# Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou, Iain Melvin, Jason Weston)\n# Copyright (c) 2006 Idiap Research Institute (Samy Bengio)\n# Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert, Samy Bengio, Johnny Mariethoz)\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n# POSSIBILITY OF SUCH DAMAGE.\nclass lazy_property(object):\n r\"\"\"\n Used as a decorator for lazy loading of class attributes. This uses a\n non-data descriptor that calls the wrapped method to compute the property on\n first call; thereafter replacing the wrapped method into an instance\n attribute.\n \"\"\"\n\n def __init__(self, wrapped):\n self.wrapped = wrapped\n update_wrapper(self, wrapped)\n\n # This is to prevent warnings from sphinx\n def __call__(self, *args, **kwargs):\n return self.wrapped(*args, **kwargs)\n\n def __get__(self, instance, obj_type=None):\n if instance is None:\n return self\n value = self.wrapped(instance)\n setattr(instance, self.wrapped.__name__, value)\n return value\n\n\ndef validate_sample(log_prob_fn):\n def wrapper(self, *args, **kwargs):\n log_prob = log_prob_fn(self, *args, *kwargs)\n if self._validate_args:\n value = kwargs['value'] if 'value' in kwargs else args[0]\n mask = self._validate_sample(value)\n log_prob = jnp.where(mask, log_prob, -jnp.inf)\n return log_prob\n\n return wrapper\n"
] | [
[
"numpy.less"
],
[
"numpy.reshape"
]
] |
tvieijra/netket | [
"ef3ff32b242f25b6a6ae0f08db1aada85775a2ea"
] | [
"Test/Machine/rbm.py"
] | [
"# Copyright 2019 The Simons Foundation, Inc. - 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 netket\nimport numpy as _np\n\n__all__ = [\"PyRbm\"]\n\n\nclass PyRbm(netket.machine.CxxMachine):\n \"\"\"\n __Do not use me in production code!__\n\n A proof of concept implementation of a complex-valued RBM in pure Python.\n This is an example of how to subclass `CxxMachine` so that the machine will\n be usable with NetKet's C++ core.\n\n This class can be used as a drop-in replacement for `RbmSpin`.\n \"\"\"\n\n def __init__(\n self, hilbert, alpha=None, use_visible_bias=True, use_hidden_bias=True\n ):\n r\"\"\"Constructs a new RBM.\n\n Args:\n hilbert: Hilbert space.\n alpha: `alpha * hilbert.size` is the number of hidden spins.\n use_visible_bias: specifies whether to use a bias for visible\n spins.\n use_hidden_bias: specifies whether to use a bias for hidden spins.\n \"\"\"\n # NOTE: The following call to __init__ is important!\n super(PyRbm, self).__init__(hilbert)\n n = hilbert.size\n if alpha < 0:\n raise ValueError(\"`alpha` should be non-negative\")\n m = int(round(alpha * n))\n self._w = _np.empty([m, n], dtype=_np.complex128)\n self._a = _np.empty(n, dtype=_np.complex128) if use_visible_bias else None\n self._b = _np.empty(m, dtype=_np.complex128) if use_hidden_bias else None\n\n def _number_parameters(self):\n r\"\"\"Returns the number of parameters in the machine. We just sum the\n sizes of all the tensors we hold.\n \"\"\"\n return (\n self._w.size\n + (self._a.size if self._a is not None else 0)\n + (self._b.size if self._b is not None else 0)\n )\n\n def _number_visible(self):\n r\"\"\"Returns the number of visible units.\n \"\"\"\n return self._w.shape[1]\n\n def _get_parameters(self):\n r\"\"\"Returns the parameters as a 1D tensor.\n\n This function tries to order parameters in the exact same way as\n ``RbmSpin`` does so that we can do stuff like\n\n >>> import netket\n >>> import numpy\n >>> hilbert = netket.hilbert.Spin(\n graph=netket.graph.Hypercube(length=100, n_dim=1),\n s=1/2.\n )\n >>> cxx_rbm = netket.machine.RbmSpin(hilbert, alpha=3)\n >>> py_rbm = netket.machine.PyRbm(hilbert, alpha=3)\n >>> cxx_rbm.init_random_parameters()\n >>> # Order of parameters is the same, so we can assign one to the\n >>> # other\n >>> py_rbm.parameters = cxx_rbm.parameters\n >>> x = np.array(hilbert.local_states, size=hilbert.size)\n >>> assert numpy.isclose(py_rbm.log_val(x), cxx_rbm.log_val(x))\n \"\"\"\n params = tuple()\n if self._a is not None:\n params += (self._a,)\n if self._b is not None:\n params += (self._b,)\n params += (self._w.reshape(-1, order=\"C\"),)\n return _np.concatenate(params)\n\n def _set_parameters(self, p):\n r\"\"\"Sets parameters from a 1D tensor.\n\n ``self._set_parameters(self._get_parameters())`` is an identity.\n \"\"\"\n i = 0\n if self._a is not None:\n self._a[:] = p[i : i + self._a.size]\n i += self._a.size\n if self._b is not None:\n self._b[:] = p[i : i + self._b.size]\n i += self._b.size\n\n self._w[:] = p[i : i + self._w.size].reshape(self._w.shape, order=\"C\")\n\n def log_val(self, x):\n r\"\"\"Computes the logarithm of the wave function given a spin\n configuration ``x``.\n \"\"\"\n r = _np.dot(self._w, x)\n if self._b is not None:\n r += self._b\n r = _np.sum(PyRbm._log_cosh(r))\n if self._a is not None:\n r += _np.dot(self._a, x)\n # Officially, we should return\n # self._w.shape[0] * 0.6931471805599453 + r\n # but the C++ implementation ignores the \"constant factor\"\n return r\n\n def der_log(self, x):\n r\"\"\"Computes the gradient of the logarithm of the wave function\n given a spin configuration ``x``.\n \"\"\"\n grad = _np.empty(self.n_par, dtype=_np.complex128)\n i = 0\n\n if self._a is not None:\n grad[i : i + self._a.size] = x\n i += self._a.size\n\n tanh_stuff = _np.dot(self._w, x)\n if self._b is not None:\n tanh_stuff += self._b\n tanh_stuff = _np.tanh(tanh_stuff, out=tanh_stuff)\n\n if self._b is not None:\n grad[i : i + self._b.size] = tanh_stuff\n i += self._b.size\n\n out = grad[i : i + self._w.size]\n out.shape = (tanh_stuff.size, x.size)\n _np.outer(tanh_stuff, x, out=out)\n\n return grad\n\n def _is_holomorphic(self):\n r\"\"\"Complex valued RBM a holomorphic function.\n \"\"\"\n return True\n\n def save(self, filename):\n r\"\"\"Saves machine weights to ``filename`` using ``pickle``.\n \"\"\"\n import pickle\n\n with open(filename, \"wb\") as output_file:\n pickle.dump((self._w, self._a, self._b), output_file)\n\n def load(self, filename):\n r\"\"\"Loads machine weights from ``filename`` using ``pickle``.\n \"\"\"\n import pickle\n\n with open(filename, \"rb\") as input_file:\n self._w, self._a, self._b = pickle.load(input_file)\n\n @staticmethod\n def _log_cosh(x):\n # TODO: Handle big numbers properly\n return _np.log(_np.cosh(x))\n"
] | [
[
"numpy.concatenate",
"numpy.dot",
"numpy.empty",
"numpy.cosh",
"numpy.tanh",
"numpy.outer"
]
] |
jameszhou-gl/CBRE | [
"53c952e0afc74518fc4223f0f20881336df20f95",
"53c952e0afc74518fc4223f0f20881336df20f95"
] | [
"cbre/cbre_net.py",
"cbre/loader.py"
] | [
"import tensorflow as tf\nimport numpy as np\nfrom cbre.util import *\n\n\nclass CBRENet(object):\n \"\"\"\n cbre_net implements the cycly-balanced representation learning for counterfactual inference\n\n The network is implemented as a tensorflow graph. The class constructor\n creates an object containing relevant TF nodes as member variables.\n \"\"\"\n\n def __init__(self, x, t, y_, p_t, z_norm, flags, r_alpha, r_lambda, r_beta, do_in, do_out, data_x_dim):\n \"\"\"\n x The varibales of data\n t The treatment applied to x, t.shape[1]==1\n y_ The true outcome\n p_t The treatment probability in all observations\n z_norm todo unknown\n flags The arg params\n r_alpha The coefficient of reconstruction and cycle loss\n r_lambda The coefficient of regularization of prediction network\n r_beta The coefficient of gradient penalty in GAN\n do_in The val of dropout_in\n do_out The val of dropout_out\n data_x_dim The dim of varibale x\n \"\"\"\n self.variables = {}\n # wd_loss: regularization l2 loss\n self.wd_loss = 0\n\n if flags.nonlin.lower() == 'elu':\n self.nonlin = tf.nn.elu\n else:\n self.nonlin = tf.nn.relu\n\n self._build_graph(x, t, y_, p_t, z_norm, flags, r_alpha, r_lambda, r_beta, do_in, do_out, data_x_dim)\n\n def _add_variable(self, var, name):\n \"\"\"\n Adds variables to the internal track-keeper\n \"\"\"\n basename = name\n i = 0\n while name in self.variables:\n name = '%s_%d' % (basename, i) # @TODO: not consistent with TF internally if changed\n i += 1\n\n self.variables[name] = var\n\n def _create_variable(self, var, name):\n \"\"\" Create and adds variables to the internal track-keeper \"\"\"\n # tf.get_variable(name=name, initializer=var)\n var = tf.Variable(var, name=name)\n self._add_variable(var, name)\n return var\n\n def _create_variable_with_weight_decay(self, initializer, name, wd):\n \"\"\" Create and adds variables to the internal track-keeper\n and adds it to the list of weight decayed variables \"\"\"\n var = self._create_variable(initializer, name)\n self.wd_loss += wd * tf.nn.l2_loss(var)\n return var\n\n def _build_graph(self, x, t, y_, p_t, z_norm, flags, r_alpha, r_lambda, r_beta, do_in, do_out, data_x_dim):\n \"\"\"\n Constructs a TensorFlow subgraph for causal effect inference.\n Sets the following member variables (to TF nodes):\n\n self.output The output prediction \"y\"\n self.tot_loss The total objective to minimize\n self.pred_loss The prediction term of the objective\n self.weights_in The input/representation layer weights\n self.weights_out The output/post-representation layer weights\n self.weights_pred The (linear) prediction layer weights\n self.h_rep The layer of the penalized representation\n \"\"\"\n self.x = x\n self.t = t\n self.y_ = y_\n self.p_t = p_t\n self.r_alpha = r_alpha\n self.r_lambda = r_lambda\n self.r_beta = r_beta\n self.do_in = do_in\n self.do_out = do_out\n self.z_norm = z_norm\n\n self.encoder_dim = flags.encoder_dim\n encoder_dim = flags.encoder_dim\n self.decoder_dim = flags.decoder_dim\n self.predictor_dim = flags.predictor_dim\n predictor_dim = flags.predictor_dim\n mi_estimator_dim = flags.mi_estimator_dim\n self.discriminator_dim = flags.discriminator_dim\n discriminator_dim = flags.discriminator_dim\n\n \"\"\"\n Network Components\n \"\"\"\n '''\n 1. Encoder Network\n '''\n # Construct Encoder network layers, four layers with size 200\n h_rep, h_rep_norm, weights_in = self._build_encoder(x, data_x_dim, flags)\n\n '''\n 2. GAN\n '''\n d0, d1, dp, weights_dis, weights_discore = self._build_adversarial_graph(h_rep_norm, t, encoder_dim,\n discriminator_dim, do_out,\n flags)\n # discriminator\n # with sigmoid\n # discriminator_loss = tf.reduce_mean(tf.nn.softplus(-d0)) + tf.reduce_mean(tf.nn.softplus(-d1) + d1) + dp\n # without sigmoid\n discriminator_loss = -tf.reduce_mean(d0) + tf.reduce_mean(d1) + r_beta * dp\n # encoder\n # with sigmoid\n # rep_loss = tf.reduce_mean(tf.nn.softplus(-d1))\n # without sigmoid\n # todo rep_loss in paper: rep_loss = tf.reduce_mean(d0) - tf.reduce_mean(d1)\n rep_loss = tf.reduce_mean(d0) - tf.reduce_mean(d1)\n # rep_loss = -tf.reduce_mean(d1)\n\n '''\n 3. Reconstruction \n '''\n # graph for reconstruction loss\n x0, recons_x_0, x1, recons_x_1 = self._build_reconstruct_graph(x, t, data_x_dim, flags)\n recons_loss = tf.sqrt(tf.reduce_mean(tf.square(x0 - recons_x_0)) + 1.0e-12) + tf.sqrt(\n tf.reduce_mean(tf.square(x1 - recons_x_1)) + 1.0e-12)\n\n '''\n 4. Cycle \n '''\n x0, cycle_x0, x1, cycle_x1 = self._build_cycle_graph(x, t, data_x_dim, flags)\n cycle_loss = tf.sqrt(tf.reduce_mean(tf.square(x0 - cycle_x0)) + 1.0e-12) + tf.sqrt(\n tf.reduce_mean(tf.square(x1 - cycle_x1)) + 1.0e-12)\n\n '''\n Predict Networks\n '''\n y, weights_out, weights_pred = self._build_output_graph(h_rep_norm, t, encoder_dim, predictor_dim, do_out,\n flags)\n\n \"\"\" Compute sample reweighting \"\"\"\n if flags.reweight_sample:\n w_t = t / (2 * p_t)\n w_c = (1 - t) / (2 * 1 - p_t)\n sample_weight = w_t + w_c\n else:\n sample_weight = 1.0\n\n self.sample_weight = sample_weight\n\n risk = tf.reduce_mean(sample_weight * tf.square(y_ - y))\n pred_error = tf.sqrt(tf.reduce_mean(tf.square(y_ - y)) + 1.0e-12)\n\n \"\"\" Regularization \"\"\"\n if flags.p_lambda > 0 and flags.rep_weight_decay:\n for i in range(0, flags.layer_num_encoder):\n if not (flags.varsel and i == 0): # No penalty on W in variable selection\n self.wd_loss += tf.nn.l2_loss(weights_in[i])\n\n \"\"\" Total error \"\"\"\n tot_error = risk\n\n if flags.p_lambda > 0:\n tot_error = tot_error + r_lambda * self.wd_loss + recons_loss + cycle_loss\n if flags.coef_recons > 0:\n tot_error += flags.coef_recons * recons_loss\n if flags.coef_cycle:\n tot_error += flags.coef_cycle * cycle_loss\n if flags.coef_d:\n tot_error += flags.coef_d * discriminator_loss\n\n if flags.varsel:\n self.w_proj = tf.placeholder(\"float\", shape=[data_x_dim], name='w_proj')\n self.projection = weights_in[0].assign(self.w_proj)\n\n self.output = y\n self.tot_loss = tot_error\n self.discriminator_loss = discriminator_loss\n self.rep_loss = rep_loss\n self.rec_loss = recons_loss\n self.cycle_loss = cycle_loss\n self.recons_cycle_loss = recons_loss + cycle_loss\n self.pred_loss = pred_error\n self.weights_in = weights_in\n self.weights_out = weights_out\n self.weights_dis = weights_dis\n self.weights_discore = weights_discore\n self.weights_pred = weights_pred\n self.h_rep = h_rep\n self.h_rep_norm = h_rep_norm\n self.dp = dp\n\n def _build_output_0(self, h_input, encoder_dim, predictor_dim, do_out, flags):\n h_out = [h_input]\n dims = [encoder_dim] + ([predictor_dim] * flags.layer_num_predictor)\n with tf.variable_scope('pred_0') as scope:\n weights_out = []\n biases_out = []\n\n for i in range(0, flags.layer_num_predictor):\n wo = tf.get_variable(name='w_{}'.format(i),\n initializer=tf.random_normal([dims[i], dims[i + 1]],\n stddev=flags.weight_init / np.sqrt(dims[i])))\n\n weights_out.append(wo)\n\n # biases_out.append(tf.Variable(tf.zeros([1, predictor_dim])))\n biases_out.append(tf.get_variable(name='b_{}'.format(i), initializer=tf.zeros([1, predictor_dim])))\n z = tf.matmul(h_out[i], weights_out[i]) + biases_out[i]\n\n h_out.append(self.nonlin(z))\n h_out[i + 1] = tf.nn.dropout(h_out[i + 1], do_out)\n\n weights_pred = self._create_variable(tf.random_normal([predictor_dim, 1],\n stddev=flags.weight_init / np.sqrt(predictor_dim)),\n 'w_pred')\n weights_pred = tf.get_variable(name='w_pred', initializer=tf.random_normal([predictor_dim, 1],\n stddev=flags.weight_init / np.sqrt(\n predictor_dim)))\n bias_pred = tf.get_variable(initializer=tf.zeros([1]), name='b_pred')\n\n if flags.varsel or flags.layer_num_predictor == 0:\n self.wd_loss += tf.nn.l2_loss(\n tf.slice(weights_pred, [0, 0], [predictor_dim - 1, 1])) # don't penalize treatment coefficient\n else:\n self.wd_loss += tf.nn.l2_loss(weights_pred)\n\n \"\"\" Construct linear classifier \"\"\"\n h_pred = h_out[-1]\n y = tf.matmul(h_pred, weights_pred) + bias_pred\n\n return y, weights_out, weights_pred\n\n def _build_output_1(self, h_input, encoder_dim, predictor_dim, do_out, flags):\n h_out = [h_input]\n dims = [encoder_dim] + ([predictor_dim] * flags.layer_num_predictor)\n with tf.variable_scope('pred_1') as scope:\n weights_out = []\n biases_out = []\n\n for i in range(0, flags.layer_num_predictor):\n wo = tf.get_variable(name='w_{}'.format(i),\n initializer=tf.random_normal([dims[i], dims[i + 1]],\n stddev=flags.weight_init / np.sqrt(dims[i])))\n\n weights_out.append(wo)\n\n # biases_out.append(tf.Variable(tf.zeros([1, predictor_dim])))\n biases_out.append(tf.get_variable(name='b_{}'.format(i), initializer=tf.zeros([1, predictor_dim])))\n z = tf.matmul(h_out[i], weights_out[i]) + biases_out[i]\n\n h_out.append(self.nonlin(z))\n h_out[i + 1] = tf.nn.dropout(h_out[i + 1], do_out)\n\n weights_pred = self._create_variable(tf.random_normal([predictor_dim, 1],\n stddev=flags.weight_init / np.sqrt(predictor_dim)),\n 'w_pred')\n weights_pred = tf.get_variable(name='w_pred', initializer=tf.random_normal([predictor_dim, 1],\n stddev=flags.weight_init / np.sqrt(\n predictor_dim)))\n bias_pred = tf.get_variable(initializer=tf.zeros([1]), name='b_pred')\n\n if flags.varsel or flags.layer_num_predictor == 0:\n self.wd_loss += tf.nn.l2_loss(\n tf.slice(weights_pred, [0, 0], [predictor_dim - 1, 1])) # don't penalize treatment coefficient\n else:\n self.wd_loss += tf.nn.l2_loss(weights_pred)\n\n \"\"\" Construct linear classifier \"\"\"\n h_pred = h_out[-1]\n y = tf.matmul(h_pred, weights_pred) + bias_pred\n\n return y, weights_out, weights_pred\n\n def _build_output_graph(self, rep, t, encoder_dim, predictor_dim, do_out, flags):\n \"\"\" Construct output/regression layers \"\"\"\n\n if flags.split_output:\n\n i0 = tf.to_int32(tf.where(t < 1)[:, 0])\n i1 = tf.to_int32(tf.where(t > 0)[:, 0])\n\n rep0 = tf.gather(rep, i0)\n rep1 = tf.gather(rep, i1)\n\n y0, weights_out0, weights_pred0 = self._build_output_0(rep0, encoder_dim, predictor_dim, do_out, flags)\n y1, weights_out1, weights_pred1 = self._build_output_1(rep1, encoder_dim, predictor_dim, do_out, flags)\n\n y = tf.dynamic_stitch([i0, i1], [y0, y1])\n weights_out = weights_out0 + weights_out1\n weights_pred = weights_pred0 + weights_pred1\n else:\n h_input = tf.concat(1, [rep, t])\n # y, weights_out, weights_pred = self._build_output(h_input, encoder_dim + 1, predictor_dim, do_out, flags)\n y, weights_out, weights_pred = None, None, None\n\n return y, weights_out, weights_pred\n\n def _build_encoder(self, x, data_x_dim, flags):\n with tf.variable_scope('encoder', reuse=tf.AUTO_REUSE) as scope:\n weights_in = []\n biases_in = []\n\n if flags.batch_norm:\n bn_biases = []\n bn_scales = []\n\n h_in = [x]\n\n for i in range(0, flags.layer_num_encoder):\n if i == 0:\n \"\"\" If using variable selection, first layer is just rescaling\"\"\"\n if flags.varsel:\n weights_in.append(tf.get_variable(name='wg_{}'.format(i),\n initializer=1.0 / data_x_dim * tf.ones([data_x_dim])))\n else:\n wg = tf.get_variable(name='wg_{}'.format(i),\n initializer=tf.random_normal([data_x_dim, self.encoder_dim],\n stddev=flags.weight_init / np.sqrt(\n data_x_dim)))\n weights_in.append(wg)\n else:\n wg = tf.get_variable(name='wg_{}'.format(i),\n initializer=tf.random_normal([self.encoder_dim, self.encoder_dim],\n stddev=flags.weight_init / np.sqrt(\n self.encoder_dim)))\n weights_in.append(wg)\n\n biases_in.append(tf.get_variable(name='bi_{}'.format(i), initializer=tf.zeros([1, self.encoder_dim])))\n # z equals outcome of each layer in Encoder Network.\n z = tf.matmul(h_in[i], weights_in[i]) + biases_in[i]\n\n if flags.batch_norm:\n batch_mean, batch_var = tf.nn.moments(z, [0])\n\n if flags.normalization == 'bn_fixed':\n z = tf.nn.batch_normalization(z, batch_mean, batch_var, 0, 1, 1e-3)\n else:\n # bn_biases.append(tf.Variable(tf.zeros([self.encoder_dim])))\n bn_biases.append(\n tf.get_variable(name='bn_b_{}'.format(i), initializer=tf.zeros([self.encoder_dim])))\n # bn_scales.append(tf.Variable(tf.ones([self.encoder_dim])))\n bn_scales.append(\n tf.get_variable(name='bn_s_{}'.format(i), initializer=tf.ones([self.encoder_dim])))\n z = tf.nn.batch_normalization(z, batch_mean, batch_var, bn_biases[-1], bn_scales[-1], 1e-3)\n\n h_in.append(self.nonlin(z))\n h_in[i + 1] = tf.nn.dropout(h_in[i + 1], self.do_in)\n\n h_rep = h_in[-1]\n\n # todo normalization meaning?\n if flags.normalization == 'divide':\n h_rep_norm = h_rep / safe_sqrt(tf.reduce_sum(tf.square(h_rep), axis=1, keep_dims=True) + 1.0e-12)\n else:\n h_rep_norm = 1.0 * h_rep\n return h_rep, h_rep_norm, weights_in\n\n def _build_decoder(self, h_rep, data_x_dim, flags, suffix='0'):\n with tf.variable_scope('decoder_' + suffix, reuse=tf.AUTO_REUSE) as scope:\n weights_in = []\n biases_in = []\n recons_x = [h_rep]\n decoder_dim = flags.decoder_dim\n for i in range(0, flags.layer_num_decoder):\n if i == 0:\n weights_in.append(tf.get_variable(name='wg_{}'.format(i),\n initializer=tf.random_normal([flags.encoder_dim, decoder_dim],\n stddev=flags.weight_init / np.sqrt(\n flags.encoder_dim))))\n biases_in.append(tf.get_variable(name='bi_{}'.format(i), initializer=tf.zeros([1, decoder_dim])))\n elif i == flags.layer_num_decoder - 1:\n weights_in.append(\n tf.get_variable(name='wg_{}'.format(i), initializer=tf.random_normal([decoder_dim, data_x_dim],\n stddev=flags.weight_init / np.sqrt(\n decoder_dim))))\n biases_in.append(tf.get_variable(name='bi_{}'.format(i), initializer=tf.zeros([1, data_x_dim])))\n\n else:\n weights_in.append(\n tf.get_variable(name='wg_{}'.format(i), initializer=tf.random_normal([decoder_dim, decoder_dim],\n stddev=flags.weight_init / np.sqrt(\n decoder_dim))))\n biases_in.append(tf.get_variable(name='bi_{}'.format(i), initializer=tf.zeros([1, decoder_dim])))\n\n # z equals outcome of each layer in Encoder Network.\n z = tf.matmul(recons_x[i], weights_in[i]) + biases_in[i]\n\n recons_x.append(self.nonlin(z))\n recons_x[i + 1] = tf.nn.dropout(recons_x[i + 1], self.do_in)\n\n recons_x = recons_x[-1]\n return recons_x, weights_in\n\n def _build_discriminator_graph_mine(self, x, hrep, data_x_dim, encoder_dim, mi_estimator_dim, flags):\n \"\"\" Construct MI estimation layers \"\"\"\n # two layers with size 200\n with tf.variable_scope('gmi') as scope:\n input_num = tf.shape(x)[0]\n x_shuffle = tf.random_shuffle(x)\n x_conc = tf.concat([x, x_shuffle], axis=0)\n y_conc = tf.concat([hrep, hrep], axis=0)\n\n # forward\n # [25, 200]\n weights_mi_x = self._create_variable(tf.random_normal([data_x_dim, mi_estimator_dim],\n stddev=flags.weight_init / np.sqrt(data_x_dim)),\n 'weights_mi_x')\n biases_mi_x = self._create_variable(tf.zeros([1, mi_estimator_dim]), 'biases_mi_x')\n # [, 200]\n lin_x = tf.matmul(x_conc, weights_mi_x) + biases_mi_x\n # [200, 200]\n weights_mi_y = self._create_variable(tf.random_normal([encoder_dim, mi_estimator_dim],\n stddev=flags.weight_init / np.sqrt(encoder_dim)),\n 'weights_mi_y')\n biases_mi_y = self._create_variable(tf.zeros([1, mi_estimator_dim]), 'biases_mi_y')\n # [, 200]\n lin_y = tf.matmul(y_conc, weights_mi_y) + biases_mi_y\n\n # lin_conc = tf.nn.relu(lin_x + lin_y)\n lin_conc = self.nonlin(lin_x + lin_y)\n\n weights_mi_pred = self._create_variable(tf.random_normal([mi_estimator_dim, 1],\n stddev=flags.weight_init / np.sqrt(\n mi_estimator_dim)),\n 'gmi_p')\n biases_mi_pred = self._create_variable(tf.zeros([1, mi_estimator_dim]), 'biases_mi_pred')\n gmi_output = tf.matmul(lin_conc, weights_mi_pred) + biases_mi_pred\n # real estimator outcome: shape=[input_num, 1]\n real_estimate = gmi_output[:input_num]\n # fake estimator outcome: shape=[input_num, 1]\n fake_estimate = gmi_output[input_num:]\n\n return real_estimate, fake_estimate, weights_mi_x, weights_mi_y, weights_mi_pred\n\n def _build_discriminator_adversarial(self, hrep, encoder_dim, discriminator_dim, do_out, flags):\n \"\"\" Construct adversarial discriminator layers \"\"\"\n with tf.variable_scope('discriminator', reuse=tf.AUTO_REUSE) as scope:\n h_dis = [hrep]\n\n weights_dis = []\n biases_dis = []\n for i in range(0, flags.layer_num_discriminator):\n\n if i == 0:\n weights_dis.append(tf.get_variable(name='wg_{}'.format(i),\n initializer=tf.random_normal([encoder_dim, discriminator_dim],\n stddev=flags.weight_init / np.sqrt(\n encoder_dim))))\n else:\n weights_dis.append(tf.get_variable(name='wg_{}'.format(i), initializer=tf.random_normal(\n [discriminator_dim, discriminator_dim],\n stddev=flags.weight_init / np.sqrt(\n discriminator_dim))))\n biases_dis.append(tf.get_variable(name='bi_{}'.format(i), initializer=tf.zeros([1, discriminator_dim])))\n z = tf.matmul(h_dis[i], weights_dis[i]) + biases_dis[i]\n h_dis.append(self.nonlin(z))\n h_dis[i + 1] = tf.nn.dropout(h_dis[i + 1], do_out)\n\n weights_discore = tf.get_variable(initializer=tf.random_normal([discriminator_dim, 1],\n stddev=flags.weight_init / np.sqrt(\n discriminator_dim)), name='dc_p')\n bias_dc = tf.get_variable(initializer=tf.zeros([1]), name='dc_b_p')\n\n h_score = h_dis[-1]\n dis_score = tf.matmul(h_score, weights_discore) + bias_dc\n\n return dis_score, weights_dis, weights_discore\n\n def _build_adversarial_graph(self, rep, t, encoder_dim, discriminator_dim, do_out, flags):\n \"\"\"\n Construct adversarial discriminator\n \"\"\"\n # three layers with size 200\n\n i0 = tf.to_int32(tf.where(t < 1)[:, 0])\n i1 = tf.to_int32(tf.where(t > 0)[:, 0])\n\n rep0 = tf.gather(rep, i0)\n rep1 = tf.gather(rep, i1)\n\n z_rep0 = tf.reduce_max(rep0, axis=0, keep_dims=True)\n z_rep1 = tf.reduce_max(rep1, axis=0, keep_dims=True)\n\n z_rep0_conc = tf.concat([z_rep0, self.z_norm], axis=1)\n z_rep1_conc = tf.concat([z_rep1, self.z_norm], axis=1)\n\n d0, weights_dis, weights_discore = self._build_discriminator_adversarial(z_rep0_conc, encoder_dim + encoder_dim,\n discriminator_dim,\n do_out, flags)\n d1, weights_dis, weights_discore = self._build_discriminator_adversarial(z_rep1_conc, encoder_dim + encoder_dim,\n discriminator_dim,\n do_out, flags)\n\n # gradient penalty\n alpha_dist = tf.contrib.distributions.Uniform(low=0., high=1.)\n alpha = alpha_dist.sample((1, 1))\n interpolated = z_rep1 + alpha * (z_rep0 - z_rep1)\n interpolated_conc = tf.concat([interpolated, self.z_norm], axis=1)\n inte_logit, weights_dis, weights_discore = self._build_discriminator_adversarial(interpolated_conc,\n encoder_dim + encoder_dim,\n discriminator_dim, do_out,\n flags)\n gradients = tf.gradients(inte_logit, [interpolated])[0]\n grad_l2 = tf.sqrt(tf.reduce_sum(tf.square(gradients), axis=[1]) + 1.0e-12)\n gradient_penalty = tf.reduce_mean(tf.square(grad_l2 - 1.0))\n\n return d0, d1, gradient_penalty, weights_dis, weights_discore\n\n def _build_reconstruct_graph(self, x, t, data_x_dim, flags):\n \"\"\" construct graph for later computing reconstruction loss easily\n\n Parameters:\n x The varibales of data\n t The treatment applied to x\n\n Returns:\n x0 x[t=0]\n reconstruct_x reconstruct x when pass encoder and decoder networks\n \"\"\"\n i0 = tf.to_int32(tf.where(t < 1)[:, 0])\n i1 = tf.to_int32(tf.where(t > 0)[:, 0])\n\n x0 = tf.gather(x, i0)\n x1 = tf.gather(x, i1)\n h_rep_0, h_rep_norm_0, weights_in_0 = self._build_encoder(x0, data_x_dim, flags)\n h_rep_1, h_rep_norm_1, weights_in_1 = self._build_encoder(x1, data_x_dim, flags)\n\n recons_x_0, _ = self._build_decoder(h_rep_norm_0, data_x_dim, flags, suffix='0')\n recons_x_1, _ = self._build_decoder(h_rep_norm_1, data_x_dim, flags, suffix='1')\n return x0, recons_x_0, x1, recons_x_1\n\n def _build_cycle_graph(self, x, t, data_x_dim, flags):\n \"\"\" construct graph for later computing cycle loss easily\n\n Parameters:\n x The varibales of data\n t The treatment applied to x\n\n Returns:\n x0 x[t=0]\n reconstruct_x reconstruct x when pass encoder and decoder networks\n \"\"\"\n i0 = tf.to_int32(tf.where(t < 1)[:, 0])\n i1 = tf.to_int32(tf.where(t > 0)[:, 0])\n\n x0 = tf.gather(x, i0)\n x1 = tf.gather(x, i1)\n # cycle x0-x1'-x0\n _, h_rep_norm_0, _ = self._build_encoder(x0, data_x_dim, flags)\n temp_x_0_in_1, _ = self._build_decoder(h_rep_norm_0, data_x_dim, flags, suffix='1')\n _, cyc_h_rep_norm_0, _ = self._build_encoder(temp_x_0_in_1, data_x_dim, flags)\n cycle_x0, _ = self._build_decoder(cyc_h_rep_norm_0, data_x_dim, flags, suffix='0')\n\n # cycle x1-x0'-x1\n _, h_rep_norm_1, _ = self._build_encoder(x1, data_x_dim, flags)\n temp_x_1_in_0, _ = self._build_decoder(h_rep_norm_1, data_x_dim, flags, suffix='0')\n _, cyc_h_rep_norm_1, _ = self._build_encoder(temp_x_1_in_0, data_x_dim, flags)\n cycle_x1, _ = self._build_decoder(cyc_h_rep_norm_1, data_x_dim, flags, suffix='1')\n\n return x0, cycle_x0, x1, cycle_x1\n",
"import os\nimport numpy as np\n\nfrom rbci.logger import Logger as Log\n\n\ndef load_result_file(file):\n arr = np.load(file)\n\n D = dict([(k, arr[k]) for k in arr.keys()])\n\n return D\n\n\ndef load_config(cfgfile):\n \"\"\" Parses a configuration file \"\"\"\n\n cfgf = open(cfgfile, 'r')\n cfg = {}\n for l in cfgf:\n ps = [p.strip() for p in l.split(':')]\n if len(ps) == 2:\n try:\n cfg[ps[0]] = float(ps[1])\n except ValueError:\n cfg[ps[0]] = ps[1]\n if cfg[ps[0]] == 'False':\n cfg[ps[0]] = False\n elif cfg[ps[0]] == 'True':\n cfg[ps[0]] = True\n cfgf.close()\n return cfg\n\n\ndef load_single_result(result_dir):\n if Log.VERBOSE:\n print('Loading %s...' % result_dir)\n\n config_path = '%s/config.txt' % result_dir\n has_config = os.path.isfile(config_path)\n if not has_config:\n print('WARNING: Could not find config.txt for %s. Skipping.' % os.path.basename(result_dir))\n config = None\n else:\n config = load_config(config_path)\n\n train_path = '%s/result.npz' % result_dir\n test_path = '%s/result.test.npz' % result_dir\n\n has_test = os.path.isfile(test_path)\n\n try:\n train_results = load_result_file(train_path)\n except:\n 'WARNING: Couldnt load result file. Skipping'\n return None\n\n n_rep = np.max([config['repetitions'], config['experiments']])\n\n # if len(train_results['pred'].shape) < 4 or train_results['pred'].shape[2] < n_rep:\n # print('WARNING: Experiment %s appears not to have finished. Skipping.' % result_dir)\n # return None\n\n if has_test:\n test_results = load_result_file(test_path)\n else:\n test_results = None\n\n return {'train': train_results, 'test': test_results, 'config': config}\n\n\ndef load_results(output_dir):\n if Log.VERBOSE:\n print('Loading results from %s...' % output_dir)\n\n ''' Detect results structure '''\n # Single result\n if os.path.isfile('%s/results.npz' % output_dir):\n # @TODO: Implement\n pass\n\n # Multiple results\n files = ['%s/%s' % (output_dir, f) for f in os.listdir(output_dir)]\n exp_dirs = [f for f in files if os.path.isdir(f)\n if os.path.isfile('%s/result.npz' % f)]\n\n if Log.VERBOSE:\n print('Found %d experiment configurations.' % len(exp_dirs))\n\n # Load each result folder\n results = []\n for dir in exp_dirs:\n dir_result = load_single_result(dir)\n if dir_result is not None:\n results.append(dir_result)\n\n return results\n\n\ndef load_data(datapath):\n \"\"\" Load dataset \"\"\"\n arr = np.load(datapath)\n xs = arr['x']\n\n HAVE_TRUTH = False\n SPARSE = False\n\n if len(xs.shape) == 1:\n SPARSE = True\n\n ts = arr['t']\n yfs = arr['yf']\n try:\n es = arr['e']\n except:\n es = None\n try:\n ate = np.mean(arr['ate'])\n except:\n ate = None\n try:\n ymul = arr['ymul'][0, 0]\n yadd = arr['yadd'][0, 0]\n except:\n ymul = 1\n yadd = 0\n try:\n ycfs = arr['ycf']\n mu0s = arr['mu0']\n mu1s = arr['mu1']\n HAVE_TRUTH = True\n except:\n print('Couldn\\'t find ground truth. Proceeding...')\n ycfs = None;\n mu0s = None;\n mu1s = None\n\n data = {'x': xs, 't': ts, 'e': es, 'yf': yfs, 'ycf': ycfs, \\\n 'mu0': mu0s, 'mu1': mu1s, 'ate': ate, 'YMUL': ymul, \\\n 'YADD': yadd, 'HAVE_TRUTH': HAVE_TRUTH, \\\n 'SPARSE': SPARSE}\n\n return data\n"
] | [
[
"tensorflow.matmul",
"tensorflow.ones",
"tensorflow.gradients",
"tensorflow.nn.moments",
"tensorflow.shape",
"tensorflow.concat",
"tensorflow.Variable",
"tensorflow.variable_scope",
"numpy.sqrt",
"tensorflow.nn.batch_normalization",
"tensorflow.dynamic_stitch",
"tensorflow.nn.dropout",
"tensorflow.zeros",
"tensorflow.where",
"tensorflow.nn.l2_loss",
"tensorflow.placeholder",
"tensorflow.contrib.distributions.Uniform",
"tensorflow.random_shuffle",
"tensorflow.reduce_max",
"tensorflow.gather",
"tensorflow.slice",
"tensorflow.reduce_mean",
"tensorflow.square"
],
[
"numpy.max",
"numpy.load",
"numpy.mean"
]
] |
caltech-netlab/gym-acnportal | [
"cacd2e4aa9159a3bf7f0b8e3db2dbb0832d76e46"
] | [
"gym_acnportal/gym_acnsim/envs/tests/test_action_spaces.py"
] | [
"# coding=utf-8\n\"\"\" Tests for SimAction and action space functions. \"\"\"\nimport unittest\nfrom typing import Callable, Dict, List, Any\nfrom unittest.mock import create_autospec\n\nimport numpy as np\nfrom gym import Space\n\nfrom ..action_spaces import (\n SimAction,\n single_charging_schedule,\n zero_centered_single_charging_schedule,\n)\nfrom ...interfaces import GymTrainedInterface\n\n\nclass TestSimAction(unittest.TestCase):\n # noinspection PyMissingOrEmptyDocstring\n @classmethod\n def setUpClass(cls) -> None:\n # The type here is Any as space_function is actually a Mock\n # object, but there's no Mock type in the typing library.\n cls.space_function: Any = create_autospec(lambda interface: Space())\n cls.to_schedule: Callable[\n [GymTrainedInterface, np.ndarray], Dict[str, List[float]]\n ] = lambda interface, array: {\"a\": [0]}\n cls.name: str = \"stub_action\"\n cls.sim_action: SimAction = SimAction(\n cls.space_function, cls.to_schedule, cls.name\n )\n cls.interface: GymTrainedInterface = create_autospec(GymTrainedInterface)\n\n def test_correct_on_init_sim_action_name(self) -> None:\n self.assertEqual(self.sim_action.name, self.name)\n\n def test_get_space(self) -> None:\n self.sim_action.get_space(self.interface)\n self.space_function.assert_called_once()\n\n def test_get_schedule(self) -> None:\n array: np.ndarray = np.array([[1, 0], [0, 1]])\n self.assertEqual(\n self.sim_action.get_schedule(self.interface, array), {\"a\": [0]}\n )\n\n\nclass TestSingleChargingSchedule(unittest.TestCase):\n # Some class variables are defined outside of setUpClass so that\n # the code inspector knows that inherited classes have these\n # attributes.\n max_rate: float = 16.0\n min_rate: float = 0.0\n negative_rate: float = -4.0\n deadband_rate: float = 6.0\n\n # noinspection PyMissingOrEmptyDocstring\n @classmethod\n def setUpClass(cls) -> None:\n cls.sim_action: SimAction = single_charging_schedule()\n cls.station_ids: List[str] = [\"T1\", \"T2\"]\n cls.offset: float = 0.5\n\n def _interface_builder(interface: Any, min_rate: float) -> Any:\n interface.station_ids = cls.station_ids\n interface.max_pilot_signal = lambda station_id: cls.max_rate\n interface.min_pilot_signal = lambda station_id: (\n min_rate if station_id == cls.station_ids[1] else cls.min_rate\n )\n return interface\n\n cls.interface: Any = _interface_builder(\n create_autospec(GymTrainedInterface), cls.min_rate\n )\n cls.interface_negative_min: Any = _interface_builder(\n create_autospec(GymTrainedInterface), cls.negative_rate\n )\n cls.interface_deadband_min: Any = _interface_builder(\n create_autospec(GymTrainedInterface), cls.deadband_rate\n )\n\n def test_correct_on_init_single_name(self) -> None:\n self.assertEqual(self.sim_action.name, \"single schedule\")\n\n def _test_space_function_helper(\n self, interface: GymTrainedInterface, min_rate: float, max_rate: float\n ) -> None:\n out_space: Space = self.sim_action.get_space(interface)\n self.assertEqual(out_space.shape, (len(self.station_ids),))\n np.testing.assert_equal(out_space.low, 2 * [min_rate])\n np.testing.assert_equal(out_space.high, 2 * [max_rate])\n self.assertEqual(out_space.dtype, \"float\")\n\n def test_single_space_function(self) -> None:\n self._test_space_function_helper(self.interface, self.min_rate, self.max_rate)\n\n def test_single_space_function_negative_min(self) -> None:\n self._test_space_function_helper(\n self.interface_negative_min, self.negative_rate, self.max_rate\n )\n\n def test_single_space_function_deadband_min(self) -> None:\n self._test_space_function_helper(\n self.interface_deadband_min, self.min_rate, self.max_rate\n )\n\n def test_single_to_schedule(self) -> None:\n good_schedule: Dict[str, List[float]] = self.sim_action.get_schedule(\n self.interface,\n np.array(\n [self.min_rate + self.offset, (self.max_rate - self.min_rate) / 2]\n ),\n )\n self.assertEqual(\n good_schedule,\n {\n self.station_ids[0]: [self.min_rate + self.offset],\n self.station_ids[1]: [(self.max_rate - self.min_rate) / 2],\n },\n )\n\n def test_single_to_bad_schedule(self) -> None:\n # The get_schedule function does not test if the input schedule\n # array is within the action space.\n bad_schedule: Dict[str, List[float]] = self.sim_action.get_schedule(\n self.interface,\n np.array([self.min_rate - self.offset, self.max_rate + self.offset]),\n )\n self.assertEqual(\n bad_schedule,\n {\n self.station_ids[0]: [self.min_rate - self.offset],\n self.station_ids[1]: [self.max_rate + self.offset],\n },\n )\n\n def test_single_error_schedule(self) -> None:\n with self.assertRaises(TypeError):\n _ = self.sim_action.get_schedule(\n self.interface,\n np.array(\n [[self.min_rate - self.offset], [self.max_rate + self.offset]]\n ),\n )\n\n\nclass TestZeroCenteredSingleChargingSchedule(TestSingleChargingSchedule):\n # noinspection PyMissingOrEmptyDocstring\n @classmethod\n def setUpClass(cls) -> None:\n super().setUpClass()\n cls.sim_action: SimAction = zero_centered_single_charging_schedule()\n cls.shifted_max = cls.max_rate - (cls.max_rate + cls.min_rate) / 2\n cls.shifted_minimums = [\n cls.min_rate - (cls.max_rate + cls.min_rate) / 2,\n cls.negative_rate - (cls.max_rate + cls.negative_rate) / 2,\n cls.min_rate - (cls.max_rate + cls.deadband_rate) / 2,\n ]\n cls.negative_max_shift = cls.max_rate - (cls.max_rate + cls.negative_rate) / 2\n\n def test_correct_on_init_single_name(self) -> None:\n self.assertEqual(self.sim_action.name, \"zero-centered single schedule\")\n\n def test_single_space_function(self) -> None:\n self._test_space_function_helper(\n self.interface, self.shifted_minimums[0], self.shifted_max\n )\n\n def test_single_space_function_negative_min(self) -> None:\n self._test_space_function_helper(\n self.interface_negative_min,\n self.shifted_minimums[1],\n self.negative_max_shift,\n )\n\n def test_single_space_function_deadband_min(self) -> None:\n self._test_space_function_helper(\n self.interface_deadband_min, self.shifted_minimums[2], self.shifted_max\n )\n\n def test_single_to_bad_schedule(self) -> None:\n # The get_schedule function does not test if the input schedule\n # array is within the action space.\n bad_schedule: Dict[str, List[float]] = self.sim_action.get_schedule(\n self.interface,\n np.array([self.min_rate - self.offset, self.max_rate + self.offset]),\n )\n self.assertEqual(\n bad_schedule,\n {\n self.station_ids[0]: [\n self.min_rate - self.offset + (self.max_rate + self.min_rate) / 2\n ],\n self.station_ids[1]: [\n self.max_rate + self.offset + (self.max_rate + self.min_rate) / 2\n ],\n },\n )\n\n def test_single_to_schedule(self) -> None:\n good_schedule: Dict[str, List[float]] = self.sim_action.get_schedule(\n self.interface,\n np.array(\n [\n self.min_rate - (self.max_rate + self.min_rate) / 2,\n self.max_rate - (self.max_rate + self.min_rate) / 2,\n ]\n ),\n )\n self.assertEqual(\n good_schedule,\n {\n self.station_ids[0]: [self.min_rate],\n self.station_ids[1]: [self.max_rate],\n },\n )\n\n\nif __name__ == \"__main__\":\n unittest.main()\n"
] | [
[
"numpy.array",
"numpy.testing.assert_equal"
]
] |
ckxy/part-of-hitogata | [
"76402d48a336fcd964d0e64bb01d959e8f07f296",
"76402d48a336fcd964d0e64bb01d959e8f07f296"
] | [
"datasets/readers/ccpd.py",
"utils/mask_tools.py"
] | [
"import os\nimport numpy as np\nfrom addict import Dict\nfrom PIL import Image\nfrom .reader import Reader\nfrom .builder import READER\n\n\n__all__ = ['CCPD2019FolderReader']\n\n\[email protected]_module()\nclass CCPD2019FolderReader(Reader):\n def __init__(self, root, **kwargs):\n super(CCPD2019FolderReader, self).__init__(**kwargs)\n\n self.root = root\n self.chars = ('京', '沪', '津', '渝', '冀', '晋', '蒙', '辽', '吉', '黑',\n '苏', '浙', '皖', '闽', '赣', '鲁', '豫', '鄂', '湘', '粤',\n '桂', '琼', '川', '贵', '云', '藏', '陕', '甘', '青', '宁',\n '新', \n '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\n 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K',\n 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',\n 'W', 'X', 'Y', 'Z', 'I', 'O', '-')\n self.img_paths = sorted(os.listdir(kwargs['root']))\n assert len(self.img_paths) > 0\n\n def get_dataset_info(self):\n return range(len(self.img_paths)), Dict({'chars': self.chars})\n\n def get_data_info(self, index):\n img = Image.open(self.img_paths[index][0])\n w, h = img.size\n return dict(h=h, w=w)\n\n def __call__(self, index):\n # index = data_dict\n # img = Image.open(os.path.join(self.root, self.img_paths[index])).convert('RGB')\n img = self.read_image(os.path.join(self.root, self.img_paths[index]))\n w, h = img.size\n path = os.path.join(self.root, self.img_paths[index])\n\n base_name = os.path.basename(self.img_paths[index])\n img_name, suffix = os.path.splitext(base_name)\n img_name = img_name.split(\"-\")[0].split(\"_\")[0]\n\n # if len(img_name) == 8:\n # print(path, 'a')\n # if img_name[2] != 'D' and img_name[2] != 'F' and img_name[-1] != 'D' and img_name[-1] != 'F':\n # print(path)\n # raise ValueError\n\n words = []\n for c in img_name:\n words.append(self.chars.index(c))\n\n # return {'image': img, 'ori_size': np.array([h, w]).astype(np.float32), 'path': path, 'seq': words, 'seq_length': len(words)}\n return dict(\n image=img,\n ori_size=np.array([h, w]).astype(np.float32),\n path=path,\n seq=words,\n seq_length=len(words)\n )\n\n def __repr__(self):\n return 'CCPD2019FolderReader(root={}, {})'.format(self.root, super(CCPD2019FolderReader, self).__repr__())\n",
"import math\nimport torch\nimport colorsys\nimport numpy as np\nfrom PIL import Image, ImageDraw, ImageFont\n\n\ndef draw_mask(img, mask, classes, colorbar=True, erase_contour=False, have_background=True):\n uni = np.unique(mask).tolist()\n have_contour = 255 in uni\n\n if have_contour and not erase_contour:\n num_classes = len(classes)\n else:\n num_classes = len(classes) - 1\n \n hsv_tuples = [(1.0 * x / num_classes, 1., 1.) for x in range(num_classes)]\n colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))\n colors = list(map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors))\n colors = [(0, 0, 0)] + colors\n\n if have_contour and not erase_contour:\n tmp = colors.pop(-1)\n for i in range(255 - len(colors)):\n colors.append((0, 0, 0))\n colors.append(tmp)\n elif have_contour and erase_contour:\n mask = np.array(mask).astype(np.int)\n mask[mask == 255] = 0\n mask = Image.fromarray(mask.astype(np.uint8))\n\n mask.putpalette(np.array(colors).flatten().tolist())\n mask = mask.convert(\"RGB\")\n\n img = Image.blend(img, mask, 0.5)\n\n if colorbar:\n if have_background and 0 in uni:\n uni.pop(0)\n if len(uni) > 0:\n colors = [colors[u] for u in uni]\n classes = [classes[u] if u != 255 else 'boundary' for u in uni]\n\n w, h = img.size\n w = w // 4\n\n bar = Image.new('RGB', (w, h), (255, 255, 255))\n l = math.sqrt(h * h + w * w)\n draw = ImageDraw.Draw(bar)\n font = ImageFont.truetype(\"fonts/arial.ttf\", int(l * 5e-2))\n\n pw = w\n ph = h // len(colors)\n\n x1, y1 = 0, (h - ph * len(colors)) // 2\n for i in range(len(colors)):\n draw.rectangle((x1, y1, x1 + pw, y1 + ph), fill=colors[i], outline=(0, 0, 0))\n draw.text((x1, y1), classes[i], fill=(0, 0, 0), font=font)\n y1 += ph\n else:\n w, h = img.size\n w = w // 4\n\n bar = Image.new('RGB', (w, h), (255, 255, 255))\n l = math.sqrt(h * h + w * w)\n draw = ImageDraw.Draw(bar)\n font = ImageFont.truetype(\"fonts/arial.ttf\", int(l * 5e-2))\n draw.text((0, 0), 'no_label', fill=(0, 0, 0), font=font)\n\n return img, bar\n else:\n return img, None\n\n\ndef pixel_accuracy(imPred, imLab):\n \"\"\"\n This function takes the prediction and label of a single image, returns pixel-wise accuracy\n To compute over many images do:\n for i = range(Nimages):\n (pixel_accuracy[i], pixel_correct[i], pixel_labeled[i]) = \\\n pixelAccuracy(imPred[i], imLab[i])\n mean_pixel_accuracy = 1.0 * np.sum(pixel_correct) / (np.spacing(1) + np.sum(pixel_labeled))\n \"\"\"\n # Remove classes from unlabeled pixels in gt image.\n # We should not penalize detections in unlabeled portions of the image.\n pixel_labeled = np.sum(imLab >= 0)\n pixel_correct = np.sum((imPred == imLab) * (imLab >= 0))\n pixel_accuracy = 1.0 * pixel_correct / pixel_labeled\n return pixel_accuracy, pixel_correct, pixel_labeled\n\n\ndef intersection_union(imPred, imLab, numClass):\n \"\"\"\n This function takes the prediction and label of a single image,\n returns intersection and union areas for each class\n To compute over many images do:\n for i in range(Nimages):\n (area_intersection[:,i], area_union[:,i]) = intersectionAndUnion(imPred[i], imLab[i])\n IoU = 1.0 * np.sum(area_intersection, axis=1) / np.sum(np.spacing(1)+area_union, axis=1)\n \"\"\"\n # Remove classes from unlabeled pixels in gt image.\n # We should not penalize detections in unlabeled portions of the image.\n imPred = imPred * (imLab >= 0)\n\n # Compute area intersection:\n intersection = imPred * (imPred == imLab)\n (area_intersection, _) = np.histogram(intersection, bins=numClass, range=(1, numClass))\n\n # Compute area union:\n (area_pred, _) = np.histogram(imPred, bins=numClass, range=(1, numClass))\n (area_lab, _) = np.histogram(imLab, bins=numClass, range=(1, numClass))\n area_union = area_pred + area_lab - area_intersection\n return area_intersection, area_union\n\n\n# pytorch version\ndef batch_pix_accuracy(output, target):\n \"\"\"PixAcc\"\"\"\n # inputs are numpy array, output 4D, target 3D\n # predict = torch.argmax(output.long(), 1) + 1\n predict = output.long() + 1\n target = target.long() + 1\n\n pixel_labeled = torch.sum(target > 0).item()\n pixel_correct = torch.sum((predict == target) * (target > 0)).item()\n assert pixel_correct <= pixel_labeled, \"Correct area should be smaller than Labeled\"\n return pixel_correct, pixel_labeled\n\n\ndef batch_intersection_union(output, target, nclass):\n \"\"\"mIoU\"\"\"\n # inputs are numpy array, output 4D, target 3D\n mini = 1\n maxi = nclass\n nbins = nclass\n # predict = torch.argmax(output, 1) + 1\n predict = output + 1\n target = target.float() + 1\n\n predict = predict.float() * (target > 0).float()\n intersection = predict * (predict == target).float()\n # areas of intersection and union\n # element 0 in intersection occur the main difference from np.bincount. set boundary to -1 is necessary.\n area_inter = torch.histc(intersection.cpu(), bins=nbins, min=mini, max=maxi)\n area_pred = torch.histc(predict.cpu(), bins=nbins, min=mini, max=maxi)\n area_lab = torch.histc(target.cpu(), bins=nbins, min=mini, max=maxi)\n area_union = area_pred + area_lab - area_inter\n assert torch.sum(area_inter > area_union).item() == 0, \"Intersection area should be smaller than Union area\"\n return area_inter.float(), area_union.float()\n"
] | [
[
"numpy.array"
],
[
"numpy.histogram",
"numpy.array",
"numpy.sum",
"numpy.unique",
"torch.sum"
]
] |
YeeCY/PASF | [
"95e548d365ea5da482c56408539d9a1514ef246b"
] | [
"rlkit/samplers/data_collector/path_collector.py"
] | [
"from collections import deque, OrderedDict\nfrom functools import partial\n\nimport numpy as np\n\nfrom rlkit.core.eval_util import create_stats_ordered_dict\nfrom rlkit.samplers.data_collector.base import PathCollector\nfrom rlkit.samplers.rollout_functions import rollout\n\n\nclass ActionAgent():\n def __init__(self):\n\n self._actions = None\n self._step = 0\n\n def reset(self):\n self._step = 0\n\n def set_action(self, actions):\n self._actions = actions\n\n def get_action(self, *args, **kwargs):\n action = self._actions[self._step]\n self._step += 1\n return action, []\n\n\nclass MdpPathCollector(PathCollector):\n def __init__(\n self,\n env,\n policy,\n max_num_epoch_paths_saved=None,\n render=False,\n render_kwargs=None,\n rollout_fn=rollout,\n save_env_in_snapshot=True,\n ):\n if render_kwargs is None:\n render_kwargs = {}\n self._env = env\n self._policy = policy\n self._max_num_epoch_paths_saved = max_num_epoch_paths_saved\n self._epoch_paths = deque(maxlen=self._max_num_epoch_paths_saved)\n self._render = render\n self._render_kwargs = render_kwargs\n self._rollout_fn = rollout_fn\n self._action_agent = ActionAgent()\n\n self._num_steps_total = 0\n self._num_paths_total = 0\n\n self._save_env_in_snapshot = save_env_in_snapshot\n\n def collect_new_paths(\n self,\n max_path_length,\n num_steps,\n discard_incomplete_paths,\n ):\n paths = []\n num_steps_collected = 0\n while num_steps_collected < num_steps:\n max_path_length_this_loop = min( # Do not go over num_steps\n max_path_length,\n num_steps - num_steps_collected,\n )\n path = self._rollout_fn(\n self._env,\n self._policy,\n max_path_length=max_path_length_this_loop,\n render=self._render,\n render_kwargs=self._render_kwargs,\n )\n path_len = len(path['actions'])\n if (\n path_len != max_path_length\n and not path['terminals'][-1]\n and discard_incomplete_paths\n ):\n break\n num_steps_collected += path_len\n paths.append(path)\n self._num_paths_total += len(paths)\n self._num_steps_total += num_steps_collected\n self._epoch_paths.extend(paths)\n return paths\n\n def collect_aligned_paths(self, path_actions, discard_incomplete_paths=True):\n paths = []\n num_steps_collected = 0\n for p in path_actions:\n max_path_length = len(p)\n self._action_agent.set_action(p)\n path = self._rollout_fn(\n self._env,\n self._action_agent,\n max_path_length=max_path_length,\n render=self._render,\n render_kwargs=self._render_kwargs,\n )\n path_len = len(path['actions'])\n if (\n path_len != max_path_length\n and not path['terminals'][-1]\n and discard_incomplete_paths\n ):\n break\n num_steps_collected += path_len\n paths.append(path)\n self._num_paths_total += len(paths)\n self._num_steps_total += num_steps_collected\n return paths\n\n def get_epoch_paths(self):\n return self._epoch_paths\n\n def end_epoch(self, epoch):\n self._epoch_paths = deque(maxlen=self._max_num_epoch_paths_saved)\n\n def get_diagnostics(self):\n path_lens = [len(path['actions']) for path in self._epoch_paths]\n stats = OrderedDict([\n ('num steps total', self._num_steps_total),\n ('num paths total', self._num_paths_total),\n ])\n stats.update(create_stats_ordered_dict(\n \"path length\",\n path_lens,\n always_show_all_stats=True,\n ))\n return stats\n\n def get_snapshot(self):\n snapshot_dict = dict(\n policy=self._policy,\n num_steps_total=self._num_steps_total,\n num_paths_total=self._num_paths_total,\n )\n if self._save_env_in_snapshot:\n snapshot_dict['env'] = self._env\n return snapshot_dict\n\n def load_from_snapshot(self, snapshot):\n self._policy = snapshot['policy']\n self._num_steps_total = snapshot['num_steps_total']\n self._num_paths_total = snapshot['num_paths_total']\n if self._save_env_in_snapshot:\n assert 'env' in snapshot\n if hasattr(self._env, '_custom_goal_sampler'):\n snapshot['env']._custom_goal_sampler = self._env._custom_goal_sampler\n self._env = snapshot['env']\n\n\nclass GoalConditionedPathCollector(MdpPathCollector):\n def __init__(\n self,\n *args,\n observation_key='observation',\n desired_goal_key='desired_goal',\n goal_sampling_mode=None,\n **kwargs\n ):\n def obs_processor(o):\n return np.hstack((o[observation_key], o[desired_goal_key]))\n\n rollout_fn = partial(\n rollout,\n preprocess_obs_for_policy_fn=obs_processor,\n )\n super().__init__(*args, rollout_fn=rollout_fn, **kwargs)\n self._observation_key = observation_key\n self._desired_goal_key = desired_goal_key\n self._goal_sampling_mode = goal_sampling_mode\n\n def collect_new_paths(self, *args, **kwargs):\n self._env.goal_sampling_mode = self._goal_sampling_mode\n return super().collect_new_paths(*args, **kwargs)\n\n def get_snapshot(self):\n snapshot = super().get_snapshot()\n snapshot.update(\n observation_key=self._observation_key,\n desired_goal_key=self._desired_goal_key,\n )\n return snapshot\n\n def load_from_snapshot(self, snapshot):\n super().load_from_snapshot(snapshot)\n self._observation_key = snapshot['observation_key']\n self._desired_goal_key = snapshot['desired_goal_key']\n\n\nclass ObsDictPathCollector(MdpPathCollector):\n def __init__(\n self,\n *args,\n observation_key='observation',\n **kwargs\n ):\n def obs_processor(obs):\n return obs[observation_key]\n\n rollout_fn = partial(\n rollout,\n preprocess_obs_for_policy_fn=obs_processor,\n )\n super().__init__(*args, rollout_fn=rollout_fn, **kwargs)\n self._observation_key = observation_key\n\n def get_snapshot(self):\n snapshot = super().get_snapshot()\n snapshot.update(\n observation_key=self._observation_key,\n )\n return snapshot\n\n\nclass VAEWrappedEnvPathCollector(GoalConditionedPathCollector):\n def __init__(\n self,\n env,\n policy,\n decode_goals=False,\n **kwargs\n ):\n \"\"\"Expects env is VAEWrappedEnv\"\"\"\n super().__init__(env, policy, **kwargs)\n self._decode_goals = decode_goals\n\n def collect_new_paths(self, *args, **kwargs):\n self._env.decode_goals = self._decode_goals\n return super().collect_new_paths(*args, **kwargs)\n"
] | [
[
"numpy.hstack"
]
] |
charliec443/plaid-rl | [
"2e8fbf389af9efecd41361df80e40e0bf932056d"
] | [
"plaidrl/exploration_strategies/ou_strategy.py"
] | [
"import numpy as np\nimport numpy.random as nr\n\nfrom plaidrl.exploration_strategies.base import RawExplorationStrategy\n\n\nclass OUStrategy(RawExplorationStrategy):\n \"\"\"\n This strategy implements the Ornstein-Uhlenbeck process, which adds\n time-correlated noise to the actions taken by the deterministic policy.\n The OU process satisfies the following stochastic differential equation:\n dxt = theta*(mu - xt)*dt + sigma*dWt\n where Wt denotes the Wiener process\n\n Based on the rllab implementation.\n \"\"\"\n\n def __init__(\n self,\n action_space,\n mu=0,\n theta=0.15,\n max_sigma=0.3,\n min_sigma=None,\n decay_period=100000,\n ):\n if min_sigma is None:\n min_sigma = max_sigma\n self.mu = mu\n self.theta = theta\n self.sigma = max_sigma\n self._max_sigma = max_sigma\n if min_sigma is None:\n min_sigma = max_sigma\n self._min_sigma = min_sigma\n self._decay_period = decay_period\n self.dim = np.prod(action_space.low.shape)\n self.low = action_space.low\n self.high = action_space.high\n self.state = np.ones(self.dim) * self.mu\n self.reset()\n\n def reset(self):\n self.state = np.ones(self.dim) * self.mu\n\n def evolve_state(self):\n x = self.state\n dx = self.theta * (self.mu - x) + self.sigma * nr.randn(len(x))\n self.state = x + dx\n return self.state\n\n def get_action_from_raw_action(self, action, t=0, **kwargs):\n ou_state = self.evolve_state()\n self.sigma = self._max_sigma - (self._max_sigma - self._min_sigma) * min(\n 1.0, t * 1.0 / self._decay_period\n )\n return np.clip(action + ou_state, self.low, self.high)\n"
] | [
[
"numpy.ones",
"numpy.prod",
"numpy.clip"
]
] |
sdwivedi/LightGBM | [
"f5ec54fbaca8bd5f72cdecbf755216c6278aafe3"
] | [
"examples/python-guide/advanced_example.py"
] | [
"# coding: utf-8\nimport json\nimport lightgbm as lgb\nimport pandas as pd\nimport numpy as np\nfrom sklearn.metrics import mean_squared_error\n\ntry:\n import cPickle as pickle\nexcept BaseException:\n import pickle\n\nprint('Loading data...')\n# load or create your dataset\ndf_train = pd.read_csv('../binary_classification/binary.train', header=None, sep='\\t')\ndf_test = pd.read_csv('../binary_classification/binary.test', header=None, sep='\\t')\nW_train = pd.read_csv('../binary_classification/binary.train.weight', header=None)[0]\nW_test = pd.read_csv('../binary_classification/binary.test.weight', header=None)[0]\n\ny_train = df_train[0]\ny_test = df_test[0]\nX_train = df_train.drop(0, axis=1)\nX_test = df_test.drop(0, axis=1)\n\nnum_train, num_feature = X_train.shape\n\n# create dataset for lightgbm\n# if you want to re-use data, remember to set free_raw_data=False\nlgb_train = lgb.Dataset(X_train, y_train,\n weight=W_train, free_raw_data=False)\nlgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train,\n weight=W_test, free_raw_data=False)\n\n# specify your configurations as a dict\nparams = {\n 'boosting_type': 'gbdt',\n 'objective': 'binary',\n 'metric': 'binary_logloss',\n 'num_leaves': 31,\n 'learning_rate': 0.05,\n 'feature_fraction': 0.9,\n 'bagging_fraction': 0.8,\n 'bagging_freq': 5,\n 'verbose': 0\n}\n\n# generate feature names\nfeature_name = ['feature_' + str(col) for col in range(num_feature)]\n\nprint('Starting training...')\n# feature_name and categorical_feature\ngbm = lgb.train(params,\n lgb_train,\n num_boost_round=10,\n valid_sets=lgb_train, # eval training data\n feature_name=feature_name,\n categorical_feature=[21])\n\nprint('Finished first 10 rounds...')\n# check feature name\nprint('7th feature name is:', lgb_train.feature_name[6])\n\nprint('Saving model...')\n# save model to file\ngbm.save_model('model.txt')\n\nprint('Dumping model to JSON...')\n# dump model to JSON (and save to file)\nmodel_json = gbm.dump_model()\n\nwith open('model.json', 'w+') as f:\n json.dump(model_json, f, indent=4)\n\n# feature names\nprint('Feature names:', gbm.feature_name())\n\n# feature importances\nprint('Feature importances:', list(gbm.feature_importance()))\n\nprint('Loading model to predict...')\n# load model to predict\nbst = lgb.Booster(model_file='model.txt')\n# can only predict with the best iteration (or the saving iteration)\ny_pred = bst.predict(X_test)\n# eval with loaded model\nprint(\"The rmse of loaded model's prediction is:\", mean_squared_error(y_test, y_pred) ** 0.5)\n\nprint('Dumping and loading model with pickle...')\n# dump model with pickle\nwith open('model.pkl', 'wb') as fout:\n pickle.dump(gbm, fout)\n# load model with pickle to predict\nwith open('model.pkl', 'rb') as fin:\n pkl_bst = pickle.load(fin)\n# can predict with any iteration when loaded in pickle way\ny_pred = pkl_bst.predict(X_test, num_iteration=7)\n# eval with loaded model\nprint(\"The rmse of pickled model's prediction is:\", mean_squared_error(y_test, y_pred) ** 0.5)\n\n# continue training\n# init_model accepts:\n# 1. model file name\n# 2. Booster()\ngbm = lgb.train(params,\n lgb_train,\n num_boost_round=10,\n init_model='model.txt',\n valid_sets=lgb_eval)\n\nprint('Finished 10 - 20 rounds with model file...')\n\n# decay learning rates\n# learning_rates accepts:\n# 1. list/tuple with length = num_boost_round\n# 2. function(curr_iter)\ngbm = lgb.train(params,\n lgb_train,\n num_boost_round=10,\n init_model=gbm,\n learning_rates=lambda iter: 0.05 * (0.99 ** iter),\n valid_sets=lgb_eval)\n\nprint('Finished 20 - 30 rounds with decay learning rates...')\n\n# change other parameters during training\ngbm = lgb.train(params,\n lgb_train,\n num_boost_round=10,\n init_model=gbm,\n valid_sets=lgb_eval,\n callbacks=[lgb.reset_parameter(bagging_fraction=[0.7] * 5 + [0.6] * 5)])\n\nprint('Finished 30 - 40 rounds with changing bagging_fraction...')\n\n\n# self-defined objective function\n# f(preds: array, train_data: Dataset) -> grad: array, hess: array\n# log likelihood loss\ndef loglikelihood(preds, train_data):\n labels = train_data.get_label()\n preds = 1. / (1. + np.exp(-preds))\n grad = preds - labels\n hess = preds * (1. - preds)\n return grad, hess\n\n\n# self-defined eval metric\n# f(preds: array, train_data: Dataset) -> name: string, eval_result: float, is_higher_better: bool\n# binary error\n# NOTE: when you do customized loss function, the default prediction value is margin\n# This may make built-in evalution metric calculate wrong results\n# For example, we are doing log likelihood loss, the prediction is score before logistic transformation\n# Keep this in mind when you use the customization\ndef binary_error(preds, train_data):\n labels = train_data.get_label()\n preds = 1. / (1. + np.exp(-preds))\n return 'error', np.mean(labels != (preds > 0.5)), False\n\n\ngbm = lgb.train(params,\n lgb_train,\n num_boost_round=10,\n init_model=gbm,\n fobj=loglikelihood,\n feval=binary_error,\n valid_sets=lgb_eval)\n\nprint('Finished 40 - 50 rounds with self-defined objective function and eval metric...')\n\n\n# another self-defined eval metric\n# f(preds: array, train_data: Dataset) -> name: string, eval_result: float, is_higher_better: bool\n# accuracy\n# NOTE: when you do customized loss function, the default prediction value is margin\n# This may make built-in evalution metric calculate wrong results\n# For example, we are doing log likelihood loss, the prediction is score before logistic transformation\n# Keep this in mind when you use the customization\ndef accuracy(preds, train_data):\n labels = train_data.get_label()\n preds = 1. / (1. + np.exp(-preds))\n return 'accuracy', np.mean(labels == (preds > 0.5)), True\n\n\ngbm = lgb.train(params,\n lgb_train,\n num_boost_round=10,\n init_model=gbm,\n fobj=loglikelihood,\n feval=lambda preds, train_data: [binary_error(preds, train_data),\n accuracy(preds, train_data)],\n valid_sets=lgb_eval)\n\nprint('Finished 50 - 60 rounds with self-defined objective function '\n 'and multiple self-defined eval metrics...')\n\nprint('Starting a new training job...')\n\n\n# callback\ndef reset_metrics():\n def callback(env):\n lgb_eval_new = lgb.Dataset(X_test, y_test, reference=lgb_train)\n if env.iteration - env.begin_iteration == 5:\n print('Add a new valid dataset at iteration 5...')\n env.model.add_valid(lgb_eval_new, 'new_valid')\n callback.before_iteration = True\n callback.order = 0\n return callback\n\n\ngbm = lgb.train(params,\n lgb_train,\n num_boost_round=10,\n valid_sets=lgb_train,\n callbacks=[reset_metrics()])\n\nprint('Finished first 10 rounds with callback function...')\n"
] | [
[
"pandas.read_csv",
"sklearn.metrics.mean_squared_error",
"numpy.exp",
"numpy.mean"
]
] |
afonchikk/Audio-Classification | [
"6acc7015ec847a64338f6300dca608a0752ba554"
] | [
"predict.py"
] | [
"from tensorflow.keras.models import load_model\nfrom clean import downsample_mono, envelope\nfrom kapre.time_frequency import STFT, Magnitude, ApplyFilterbank, MagnitudeToDecibel\nfrom sklearn.preprocessing import LabelEncoder\nimport numpy as np\nfrom glob import glob\nimport argparse\nimport os\nimport pandas as pd\nfrom tqdm import tqdm\n\n\ndef make_prediction(args):\n # load the model\n model = load_model(args.model_fn,\n custom_objects={'STFT': STFT,\n 'Magnitude': Magnitude,\n 'ApplyFilterbank': ApplyFilterbank,\n 'MagnitudeToDecibel': MagnitudeToDecibel})\n\n # find the sound data\n wav_paths = glob('{}/**'.format(args.src_dir), recursive=True)\n wav_paths = sorted([x.replace(os.sep, '/') for x in wav_paths if '.wav' in x])\n classes = sorted(os.listdir(args.src_dir))\n labels = [os.path.split(x)[0].split('/')[-1] for x in wav_paths]\n le = LabelEncoder()\n y_true = le.fit_transform(labels)\n results = []\n\n for z, wav_fn in tqdm(enumerate(wav_paths), total=len(wav_paths)):\n rate, wav = downsample_mono(wav_fn, args.sr)\n mask, env = envelope(wav, rate, threshold=args.threshold)\n clean_wav = wav[mask]\n step = int(args.sr * args.dt)\n batch = []\n\n for i in range(0, clean_wav.shape[0], step):\n sample = clean_wav[i:i + step]\n sample = sample.reshape(-1, 1)\n if sample.shape[0] < step:\n tmp = np.zeros(shape=(step, 1), dtype=np.float32)\n tmp[:sample.shape[0], :] = sample.flatten().reshape(-1, 1)\n sample = tmp\n batch.append(sample)\n X_batch = np.array(batch, dtype=np.float32)\n y_pred = model.predict(X_batch)\n y_mean = np.mean(y_pred, axis=0)\n y_pred = np.argmax(y_mean)\n real_class = os.path.dirname(wav_fn).split('/')[-1]\n print('Actual class: {}, Predicted class: {}'.format(real_class, classes[y_pred]))\n results.append(y_mean)\n\n np.save(os.path.join('logs', args.pred_fn), np.array(results))\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(description='Audio Classification Training')\n parser.add_argument('--model_fn', type=str, default='models/lstm.h5',\n help='model file to make predictions')\n parser.add_argument('--pred_fn', type=str, default='y_pred',\n help='fn to write predictions in logs dir')\n parser.add_argument('--src_dir', type=str, default='wavfiles',\n help='directory containing wavfiles to predict')\n parser.add_argument('--dt', type=float, default=1.0,\n help='time in seconds to sample audio')\n parser.add_argument('--sr', type=int, default=16000,\n help='sample rate of clean audio')\n parser.add_argument('--threshold', type=str, default=20,\n help='threshold magnitude for np.int16 dtype')\n args, _ = parser.parse_known_args()\n\n make_prediction(args)\n"
] | [
[
"sklearn.preprocessing.LabelEncoder",
"numpy.array",
"numpy.zeros",
"numpy.mean",
"tensorflow.keras.models.load_model",
"numpy.argmax"
]
] |
electr0de/APControllerProjectGit | [
"141ac08e716d6ac8cebe7b144b744744024d8939",
"141ac08e716d6ac8cebe7b144b744744024d8939"
] | [
"simglucose/controller/PaperController.py",
"simglucose/simulation/theta_init.py"
] | [
"from functools import partial\nfrom pprint import pprint\nimport matplotlib.pyplot as plt\n\n# import test2\nfrom simglucose.controller.base import Controller\n#from datetime import datetime, timedelta, time\nimport numpy as np\nimport math\n\npercent_value = 0.05\n\nsign = lambda x: math.copysign(1, x)\n\nnormalize_f = lambda x: (x - 39) / (600 - 39)\n\n\nclass PaperRLController(Controller):\n\n def __init__(self, a_hyper=1, a_hypo=10, current_breakfast_bolus=0.0, current_lunch_bolus=0.0,\n current_dinner_bolus=0.0, current_basal_rate=0.0, current_snack_bolus=0.0, init_state=None):\n super().__init__(init_state)\n np.random.seed(1)\n\n self.a_hyper = a_hyper\n self.hypo = a_hypo\n self.GL = normalize_f(90)\n self.GH = normalize_f(150)\n self.current_basal_rate = current_basal_rate\n self.current_breakfast_bolus = current_breakfast_bolus # bolus means IC ratio\n self.current_lunch_bolus = current_lunch_bolus\n self.current_dinner_bolus = current_dinner_bolus\n # self.current_snack_bolus = current_snack_bolus\n self.basal_theta = []\n self.bolus_theta = []\n # np.random.seed(2)\n # self.bolus_theta = np.random.rand(2).tolist()\n self.h = 0.5\n self.c_sigma = 0.05\n self.m = 0.5\n self.previous_basal_rate = 0.0\n np.random.seed(55)\n self.w = (np.random.rand(2) * 2 - 1).tolist()\n self._lambda = 0.5\n self.gamma = 0.9\n self.z = [0.0, 0.0]\n self.a = 0.5\n self.beta = 0.5\n self.beta_basal = 0.5\n self.value_factor = 10\n # self.time_array = []\n # self.theta_array_1 = []\n # self.theta_array_2 = []\n # self.bolus_time_array = []\n # self.F_1_array = []\n # self.F_2_array = []\n # plt.figure(200)\n # self.fig, self.axis = plt.subplots(4)\n # plt.show()\n # self.axis[0].set_title(\" Hyper feature for basal\")\n # self.axis[1].set_title(\" Hypo feature for basal\")\n # self.axis[2].set_title(\"Hyper theta for basal\")\n # self.axis[3].set_title(\" Hypo theta for basal\")\n\n self.previous_state_basal = None\n self.previous_state_breakfast = None\n self.previous_state_lunch = None\n self.previous_state_dinner = None\n\n def extract_features(self, array):\n M_hyper = []\n M_hypo = []\n\n for element in array:\n if element > 150:\n M_hyper.append(normalize_f(element))\n elif element < 90:\n M_hypo.append(normalize_f(element))\n\n F_hyper = sum([element - self.GH for element in M_hyper]) * 1 / len(M_hyper) if M_hyper else 0\n\n F_hypo = sum([self.GL - element for element in M_hypo]) * 1 / len(M_hypo) if M_hypo else 0\n\n return (F_hyper, F_hypo)\n\n def calculate_basal(self, previous_state, basal_array, time):\n F_hyper, F_hypo = self.extract_features(basal_array)\n F_hyper_prev, F_hypo_prev = self.extract_features(previous_state)\n\n #\n # self.F_1_array.append(F_hyper)\n # self.F_2_array.append(F_hypo)\n # self.time_array.append(time)\n #\n # self.axis[0].plot(self.time_array, self.F_1_array)\n #\n # self.axis[1].plot(self.time_array, self.F_2_array)\n #\n # plt.pause(0.001)\n\n Ps = None\n if F_hypo == 0.0:\n Ps = 0\n elif F_hypo > 0.0 and F_hyper == 0.0:\n Ps = -0.1 * F_hypo\n elif F_hypo > 0.0 and F_hyper > 0.0:\n Ps = -0.05 * F_hypo\n\n assert Ps is not None, \"No conditions matched\"\n\n P = self.perform_update(Ps, (F_hyper_prev, F_hypo_prev), (F_hyper, F_hypo), True)\n\n self.previous_basal_rate = self.current_basal_rate\n\n br_change = self.m * P * self.current_basal_rate\n\n # uncomment to enable 5 % change\n # percent_value = 0\n if abs(br_change / self.current_basal_rate) > percent_value:\n self.current_basal_rate += self.current_basal_rate * percent_value * sign(br_change)\n print(\" used % changed\")\n else:\n self.current_basal_rate += br_change\n print(\" didn't use % changed\")\n return self.current_basal_rate\n\n def calculate_bolus(self, previous_state, next_state, food_counter, time):\n F_hyper, F_hypo = self.extract_features(next_state)\n\n F_hyper_prev, F_hypo_prev = self.extract_features(previous_state)\n\n #\n # self.F_1_array.append(F_hyper)\n # self.F_2_array.append(F_hypo)\n # self.bolus_time_array.append(time)\n #\n # self.axis[0].plot(self.bolus_time_array, self.F_1_array)\n # self.axis[1].plot(self.bolus_time_array, self.F_2_array)\n\n Ps = None\n if F_hypo == 0.0:\n Ps = 0\n elif F_hypo > 0.0 and F_hyper == 0.0:\n Ps = +0.1 * F_hypo\n elif F_hypo > 0.0 and F_hyper > 0.0:\n Ps = +0.05 * F_hypo\n\n assert Ps is not None, \"No conditions matched\"\n\n P = self.perform_update(Ps, (F_hyper_prev, F_hypo_prev), (F_hyper, F_hypo), False, food_counter)\n\n if food_counter == 0:\n self.current_breakfast_bolus = self.update_bolus(self.current_breakfast_bolus, P)\n return self.current_breakfast_bolus\n\n if food_counter == 1:\n self.current_lunch_bolus = self.update_bolus(self.current_lunch_bolus, P)\n return self.current_lunch_bolus\n\n if food_counter == 2:\n self.current_dinner_bolus = self.update_bolus(self.current_dinner_bolus, P)\n return self.current_dinner_bolus\n # if food_counter == 3:\n # self.current_snack_bolus = self.update_bolus(self.current_snack_bolus, P)\n # return self.current_snack_bolus\n return 0.0\n\n def perform_update(self, Ps, F_old, F, coming_from, food_counter=None):\n\n if coming_from:\n theta = self.basal_theta\n previous_state = self.previous_state_basal\n else:\n theta = self.bolus_theta\n if food_counter == 0:\n previous_state = self.previous_state_breakfast\n elif food_counter == 1:\n previous_state = self.previous_state_lunch\n elif food_counter == 2:\n previous_state = self.previous_state_dinner\n else:\n return 0\n\n # theta = self.theta\n\n print(f\"theta: {theta}\")\n\n Pa = sum([element1 * element2 for element1, element2 in zip(F, theta)])\n\n Pd = self.h * Pa + (1 - self.h) * Ps\n\n sigma = self.c_sigma * (F[0] ** 2 + F[1] ** 2)\n\n Pe = Pd + np.random.normal(0, sigma)\n\n cost = 1 * F[0] + self.value_factor * F[1]\n\n if not previous_state:\n previous_state = sum(\n [((Pe - Pd) / sigma ** 2 * self.h * element1) * element2 for element1, element2 in zip(F_old, self.w)])\n\n next_value = sum(\n [((Pe - Pd) / sigma ** 2 * self.h * element1) * element2 for element1, element2 in zip(F, self.w)])\n d = cost + self.gamma * next_value - previous_state\n\n self.w = [element1 + self.a * d * element2 for element1, element2 in zip(self.w, self.z)]\n\n self.z = [self._lambda * element1 + element2 for element1, element2 in zip(self.z, F)]\n\n if coming_from:\n self.basal_theta = [element1 - self.beta_basal * d * (Pe - Pd) / sigma ** 2 * self.h * element2 for\n element1, element2 in zip(self.basal_theta, F)]\n self.previous_state_basal = next_value\n else:\n self.bolus_theta = [element1 - self.beta * d * (Pe - Pd) / sigma ** 2 * self.h * element2 for\n element1, element2 in zip(self.bolus_theta, F)]\n\n if food_counter == 0:\n self.previous_state_breakfast = next_value\n elif food_counter == 1:\n self.previous_state_lunch = next_value\n else:\n self.previous_state_dinner = next_value\n\n assert sigma > 0.0000001, \"sigma is too low\"\n # self.theta_array_1.append(self.theta[0])\n # self.theta_array_2.append(self.theta[1])\n # self.axis[2].plot(self.time_array, self.theta_array_1)\n # self.axis[3].plot(self.time_array, self.theta_array_2)\n\n return Pe\n\n def update_bolus(self, old_bolus, P):\n fusion_rate = old_bolus + self.m * P * old_bolus\n\n l = 1 if (self.current_basal_rate > self.previous_basal_rate and fusion_rate < old_bolus) or (\n self.current_basal_rate < self.previous_basal_rate and fusion_rate > old_bolus) else 0\n\n # fusion_rate = l * old_bolus + (1 - l) * fusion_rate\n bl_change = fusion_rate - old_bolus\n\n if abs(bl_change / old_bolus) > percent_value:\n old_bolus += sign(bl_change) * old_bolus * percent_value\n print(\" used % changed\")\n else:\n old_bolus += bl_change\n print(\" didn't use % changed\")\n return old_bolus\n\n# if __name__ == '__main__':\n#\n# GL = normalize_f(90)\n# GH = normalize_f(150)\n#\n# def extract_features(array):\n# M_hyper = []\n# M_hypo = []\n#\n# for element in array:\n# if element > 150:\n# M_hyper.append(normalize_f(element))\n# elif element < 90:\n# M_hypo.append(normalize_f(element))\n#\n# F_hyper = sum([element - GH for element in M_hyper]) * 1 / len(M_hyper) if M_hyper else 0\n#\n# F_hypo = sum([GL - element for element in M_hypo]) * 1 / len(M_hypo) if M_hypo else 0\n#\n# return (F_hyper, F_hypo)\n#\n# array = test2.array\n# print(extract_features(array))\n",
"from dataclasses import dataclass\nfrom pprint import pprint\n\nimport numpy as np\nfrom PyIF import te_compute as te\n\n\n@dataclass\nclass ThetaInit:\n def __init__(self, u2ss, BW, TDI):\n # constants\n self.u2ss = u2ss\n self.BW = BW\n self.TDI = TDI[0]\n self.aIOB = 5.0\n\n self.d = int(21 / 3)\n\n self.Wh = 0.1\n self.Wl = -0.2\n\n # signals\n self.g_sig = []\n\n def send_glucose(self, g):\n self.g_sig.append(g)\n\n def calculate_theta(self):\n g_sig = np.array(self.g_sig)\n\n basal = self._calc_basal()\n u0 = self._calc_u0(basal)\n IOBbasal = self._calc_IOBbasal(u0)\n IOB_TDI = self._calc_IOB_TDI()\n\n dg_sig = self._calc_dg()\n d2g_sig = self._calc_d2g(dg_sig)\n IOB_max = self._calc_IOBmax(IOBbasal, IOB_TDI, g_sig, dg_sig, d2g_sig)\n IA = IOB_max + basal\n\n g_sig = g_sig[self.d:]\n IA = IA[:len(g_sig)]\n\n TE = te.te_compute(IA, g_sig, k=1, embedding=1, safetyCheck=False, GPU=False)\n return self.Wh / TE, self.Wl / TE\n\n def _calc_basal(self):\n return self.u2ss * self.BW / 6000 * 60\n\n def _calc_u0(self, basal):\n if basal >= 1.25:\n return 0.85 * basal\n if self.g_sig[0] >= 100:\n return 1 * basal\n if self.g_sig[0] < 100:\n return 0.75 * basal\n\n raise Exception(\"no conditions matched\")\n\n def _calc_IOBbasal(self, u0):\n return self.aIOB * u0\n\n def _calc_IOB_TDI(self):\n if self.TDI <= 25:\n return 0.11 * self.TDI\n if 25 < self.TDI <= 35:\n return 0.125 * self.TDI\n if 35 < self.TDI <= 45:\n return 0.12 * self.TDI\n if 45 < self.TDI <= 55:\n return 0.175 * self.TDI\n if 55 < self.TDI:\n return 0.2 * self.TDI\n\n raise Exception(\"no conditions matched\")\n\n def _calc_dg(self):\n return np.diff(self.g_sig) / 3\n\n def _calc_d2g(self, dg_sig):\n return np.diff(dg_sig) / 3\n\n def _calc_IOBmax(self, IOBbasal, IOB_TDI, g_sig, dg_sig, d2g_sig):\n g_sig = g_sig[2:]\n dg_sig = dg_sig[1:]\n\n def calc(g, dg, ddg):\n if g < 125:\n return 1.10 * IOBbasal\n\n if 150 <= g and dg > 0.25 and ddg > 0.035:\n return max(IOB_TDI, 2.5 * IOBbasal)\n\n if 175 <= g and dg > 0.35 and ddg > 0.035:\n return max(IOB_TDI, 3.5 * IOBbasal)\n\n if 200 <= g and dg > -0.05:\n return max(IOB_TDI, 3.5 * IOBbasal)\n\n if 200 <= g and dg > 0.15:\n return max(IOB_TDI, 4.5 * IOBbasal)\n\n if 200 <= g and dg > 0.3:\n return max(IOB_TDI, 6.5 * IOBbasal)\n\n if self.TDI < 30:\n return 0.95 * IOBbasal\n\n if 125 <= g:\n return 1.35 * IOBbasal\n\n raise Exception(\"no conditions matched\")\n\n return np.array([calc(g, dg, ddg) for g, dg, ddg in zip(g_sig, dg_sig, d2g_sig)])\n"
] | [
[
"numpy.random.seed",
"numpy.random.normal",
"numpy.random.rand"
],
[
"numpy.array",
"numpy.diff"
]
] |
0Miquel/LIIF-temporal | [
"b992cb87cb9bdeba6d4c9bc3960b36ba52a1ba75"
] | [
"models/rdn.py"
] | [
"# Residual Dense Network for Image Super-Resolution\r\n# https://arxiv.org/abs/1802.08797\r\n# modified from: https://github.com/thstkdgus35/EDSR-PyTorch\r\n\r\nfrom argparse import Namespace\r\n\r\nimport torch\r\nimport torch.nn as nn\r\n\r\nfrom models import register\r\n\r\n\r\nclass RDB_Conv(nn.Module):\r\n def __init__(self, inChannels, growRate, kSize=3):\r\n super(RDB_Conv, self).__init__()\r\n Cin = inChannels\r\n G = growRate\r\n self.conv = nn.Sequential(*[\r\n #nn.Conv2d(Cin, G, kSize, padding=(kSize-1)//2, stride=1),\r\n nn.Conv3d(Cin, G, kSize, padding=(kSize - 1) // 2, stride=1),\r\n nn.ReLU()\r\n ])\r\n\r\n def forward(self, x):\r\n out = self.conv(x)\r\n return torch.cat((x, out), 1)\r\n\r\nclass RDB(nn.Module):\r\n def __init__(self, growRate0, growRate, nConvLayers, kSize=3):\r\n super(RDB, self).__init__()\r\n G0 = growRate0\r\n G = growRate\r\n C = nConvLayers\r\n\r\n convs = []\r\n for c in range(C):\r\n convs.append(RDB_Conv(G0 + c*G, G))\r\n self.convs = nn.Sequential(*convs)\r\n\r\n # Local Feature Fusion\r\n self.LFF = nn.Conv3d(G0 + C * G, G0, 1, padding=0, stride=1)\r\n #self.LFF = nn.Conv2d(G0 + C*G, G0, 1, padding=0, stride=1)\r\n\r\n def forward(self, x):\r\n return self.LFF(self.convs(x)) + x\r\n\r\nclass RDN(nn.Module):\r\n def __init__(self, args):\r\n super(RDN, self).__init__()\r\n self.args = args\r\n r = args.scale[0]\r\n G0 = args.G0\r\n kSize = args.RDNkSize\r\n\r\n # number of RDB blocks, conv layers, out channels\r\n self.D, C, G = {\r\n 'A': (20, 6, 32),\r\n 'B': (16, 8, 64),\r\n }[args.RDNconfig]\r\n\r\n # Shallow feature extraction net\r\n #self.SFENet1 = nn.Conv2d(args.n_colors, G0, kSize, padding=(kSize-1)//2, stride=1)\r\n #self.SFENet2 = nn.Conv2d(G0, G0, kSize, padding=(kSize-1)//2, stride=1)\r\n self.SFENet1 = nn.Conv3d(args.n_colors, G0, kSize, padding=(kSize-1)//2, stride=1)\r\n self.SFENet2 = nn.Conv3d(G0, G0, kSize, padding=(kSize-1)//2, stride=1)\r\n\r\n # Redidual dense blocks and dense feature fusion\r\n self.RDBs = nn.ModuleList()\r\n for i in range(self.D):\r\n self.RDBs.append(\r\n RDB(growRate0 = G0, growRate = G, nConvLayers = C)\r\n )\r\n\r\n # Global Feature Fusion\r\n self.GFF = nn.Sequential(*[\r\n #nn.Conv2d(self.D * G0, G0, 1, padding=0, stride=1),\r\n #nn.Conv2d(G0, G0, kSize, padding=(kSize-1)//2, stride=1)\r\n nn.Conv3d(self.D * G0, G0, 1, padding=0, stride=1),\r\n nn.Conv3d(G0, G0, kSize, padding=(kSize - 1) // 2, stride=1)\r\n ])\r\n\r\n if args.no_upsampling:\r\n self.out_dim = G0\r\n else:\r\n self.out_dim = args.n_colors\r\n # Up-sampling net\r\n if r == 2 or r == 3:\r\n self.UPNet = nn.Sequential(*[\r\n nn.Conv2d(G0, G * r * r, kSize, padding=(kSize-1)//2, stride=1),\r\n nn.PixelShuffle(r),\r\n nn.Conv2d(G, args.n_colors, kSize, padding=(kSize-1)//2, stride=1)\r\n ])\r\n elif r == 4:\r\n self.UPNet = nn.Sequential(*[\r\n nn.Conv2d(G0, G * 4, kSize, padding=(kSize-1)//2, stride=1),\r\n nn.PixelShuffle(2),\r\n nn.Conv2d(G, G * 4, kSize, padding=(kSize-1)//2, stride=1),\r\n nn.PixelShuffle(2),\r\n nn.Conv2d(G, args.n_colors, kSize, padding=(kSize-1)//2, stride=1)\r\n ])\r\n else:\r\n raise ValueError(\"scale must be 2 or 3 or 4.\")\r\n\r\n def forward(self, x):\r\n f__1 = self.SFENet1(x)\r\n x = self.SFENet2(f__1)\r\n\r\n RDBs_out = []\r\n for i in range(self.D):\r\n x = self.RDBs[i](x)\r\n RDBs_out.append(x)\r\n\r\n x = self.GFF(torch.cat(RDBs_out,1))\r\n x += f__1\r\n\r\n if self.args.no_upsampling:\r\n return x\r\n else:\r\n return self.UPNet(x)\r\n\r\n\r\n@register('rdn')\r\ndef make_rdn(G0=64, RDNkSize=3, RDNconfig='B',\r\n scale=2, no_upsampling=False):\r\n args = Namespace()\r\n args.G0 = G0\r\n args.RDNkSize = RDNkSize\r\n args.RDNconfig = RDNconfig\r\n\r\n args.scale = [scale]\r\n args.no_upsampling = no_upsampling\r\n\r\n args.n_colors = 3\r\n return RDN(args)\r\n"
] | [
[
"torch.cat",
"torch.nn.ModuleList",
"torch.nn.Sequential",
"torch.nn.ReLU",
"torch.nn.PixelShuffle",
"torch.nn.Conv2d",
"torch.nn.Conv3d"
]
] |
danagi/tianshou | [
"c97aa4065ee8464bd5897bb86f1f81abd8e2cff9"
] | [
"tianshou/policy/modelfree/discrete_sac.py"
] | [
"import torch\nimport numpy as np\nfrom torch.distributions import Categorical\nfrom typing import Any, Dict, Tuple, Union, Optional\n\nfrom tianshou.policy import SACPolicy\nfrom tianshou.data import Batch, ReplayBuffer, to_torch\n\n\nclass DiscreteSACPolicy(SACPolicy):\n \"\"\"Implementation of SAC for Discrete Action Settings. arXiv:1910.07207.\n\n :param torch.nn.Module actor: the actor network following the rules in\n :class:`~tianshou.policy.BasePolicy`. (s -> logits)\n :param torch.optim.Optimizer actor_optim: the optimizer for actor network.\n :param torch.nn.Module critic1: the first critic network. (s -> Q(s))\n :param torch.optim.Optimizer critic1_optim: the optimizer for the first\n critic network.\n :param torch.nn.Module critic2: the second critic network. (s -> Q(s))\n :param torch.optim.Optimizer critic2_optim: the optimizer for the second\n critic network.\n :param float tau: param for soft update of the target network, defaults to\n 0.005.\n :param float gamma: discount factor, in [0, 1], defaults to 0.99.\n :param (float, torch.Tensor, torch.optim.Optimizer) or float alpha: entropy\n regularization coefficient, default to 0.2.\n If a tuple (target_entropy, log_alpha, alpha_optim) is provided, then\n alpha is automatatically tuned.\n :param bool reward_normalization: normalize the reward to Normal(0, 1),\n defaults to ``False``.\n :param bool ignore_done: ignore the done flag while training the policy,\n defaults to ``False``.\n\n .. seealso::\n\n Please refer to :class:`~tianshou.policy.BasePolicy` for more detailed\n explanation.\n \"\"\"\n\n def __init__(\n self,\n actor: torch.nn.Module,\n actor_optim: torch.optim.Optimizer,\n critic1: torch.nn.Module,\n critic1_optim: torch.optim.Optimizer,\n critic2: torch.nn.Module,\n critic2_optim: torch.optim.Optimizer,\n tau: float = 0.005,\n gamma: float = 0.99,\n alpha: Union[\n float, Tuple[float, torch.Tensor, torch.optim.Optimizer]\n ] = 0.2,\n reward_normalization: bool = False,\n ignore_done: bool = False,\n estimation_step: int = 1,\n **kwargs: Any,\n ) -> None:\n super().__init__(actor, actor_optim, critic1, critic1_optim, critic2,\n critic2_optim, (-np.inf, np.inf), tau, gamma, alpha,\n reward_normalization, ignore_done, estimation_step,\n **kwargs)\n self._alpha: Union[float, torch.Tensor]\n\n def forward( # type: ignore\n self,\n batch: Batch,\n state: Optional[Union[dict, Batch, np.ndarray]] = None,\n input: str = \"obs\",\n **kwargs: Any,\n ) -> Batch:\n obs = batch[input]\n logits, h = self.actor(obs, state=state, info=batch.info)\n dist = Categorical(logits=logits)\n act = dist.sample()\n return Batch(logits=logits, act=act, state=h, dist=dist)\n\n def _target_q(\n self, buffer: ReplayBuffer, indice: np.ndarray\n ) -> torch.Tensor:\n batch = buffer[indice] # batch.obs: s_{t+n}\n with torch.no_grad():\n obs_next_result = self(batch, input=\"obs_next\")\n dist = obs_next_result.dist\n target_q = dist.probs * torch.min(\n self.critic1_old(batch.obs_next),\n self.critic2_old(batch.obs_next),\n )\n target_q = target_q.sum(dim=-1) + self._alpha * dist.entropy()\n return target_q\n\n def learn(self, batch: Batch, **kwargs: Any) -> Dict[str, float]:\n weight = batch.pop(\"weight\", 1.0)\n target_q = batch.returns.flatten()\n act = to_torch(\n batch.act[:, np.newaxis], device=target_q.device, dtype=torch.long)\n\n # critic 1\n current_q1 = self.critic1(batch.obs).gather(1, act).flatten()\n td1 = current_q1 - target_q\n critic1_loss = (td1.pow(2) * weight).mean()\n\n self.critic1_optim.zero_grad()\n critic1_loss.backward()\n self.critic1_optim.step()\n\n # critic 2\n current_q2 = self.critic2(batch.obs).gather(1, act).flatten()\n td2 = current_q2 - target_q\n critic2_loss = (td2.pow(2) * weight).mean()\n\n self.critic2_optim.zero_grad()\n critic2_loss.backward()\n self.critic2_optim.step()\n batch.weight = (td1 + td2) / 2.0 # prio-buffer\n\n # actor\n dist = self(batch).dist\n entropy = dist.entropy()\n with torch.no_grad():\n current_q1a = self.critic1(batch.obs)\n current_q2a = self.critic2(batch.obs)\n q = torch.min(current_q1a, current_q2a)\n actor_loss = -(self._alpha * entropy\n + (dist.probs * q).sum(dim=-1)).mean()\n self.actor_optim.zero_grad()\n actor_loss.backward()\n self.actor_optim.step()\n\n if self._is_auto_alpha:\n log_prob = -entropy.detach() + self._target_entropy\n alpha_loss = -(self._log_alpha * log_prob).mean()\n self._alpha_optim.zero_grad()\n alpha_loss.backward()\n self._alpha_optim.step()\n self._alpha = self._log_alpha.detach().exp()\n\n self.sync_weight()\n\n result = {\n \"loss/actor\": actor_loss.item(),\n \"loss/critic1\": critic1_loss.item(),\n \"loss/critic2\": critic2_loss.item(),\n }\n if self._is_auto_alpha:\n result[\"loss/alpha\"] = alpha_loss.item()\n result[\"alpha\"] = self._alpha.item() # type: ignore\n\n return result\n"
] | [
[
"torch.no_grad",
"torch.distributions.Categorical",
"torch.min"
]
] |
mayanks888/second.pytorch | [
"02d37885a543ee46516648dcab7db8f5d677a179",
"02d37885a543ee46516648dcab7db8f5d677a179"
] | [
"second/mayank_scripts/infer_ros_melodic_pretained_same_frame.py",
"second/mayank_scripts/infer_ros2.py"
] | [
"#!/usr/bin/env python\n# ROS node libs\n\nimport time\n\nimport numpy as np\nimport rospy\nimport torch\n# from geometry_msgs.msg import Quaternion, Pose, Point, Vector3\nfrom pyquaternion import Quaternion\nfrom google.protobuf import text_format\nfrom sensor_msgs.msg import PointCloud2\nfrom std_msgs.msg import Header, ColorRGBA\n# from cv_bridge import CvBridge, CvBridgeError\nfrom visualization_msgs.msg import Marker, MarkerArray\n\nfrom second.protos import pipeline_pb2\n# from second.utils import simplevis\nfrom second.pytorch.train import build_network\nfrom second.utils import config_tool\nfrom std_msgs.msg import Int16, Float32MultiArray\nfrom jsk_recognition_msgs.msg import BoundingBox, BoundingBoxArray\n# import ros_numpy\n\n\n# GPU settings: Select GPUs to use. Coment it to let the system decide\n# os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n\nclass ros_tensorflow_obj():\n def __init__(self):\n # ## Initial msg\n rospy.loginfo(' ## Starting ROS interface ##')\n # ## Load a (frozen) Tensorflow model into memory.\n print(\"ready to process----------------------------------------------------------\")\n ####################################################################################333\n # config_path = \"../configs/nuscenes/all.pp.largea.config\"\n # config_path = \"/home/mayank_sati/codebase/python/lidar/second.pytorch/second/configs/pointpillars/car/xyres_28.config\"\n config_path = \"/home/mayank_sati/codebase/python/lidar/second.pytorch/second/configs/pointpillars/car/xyres_24.config\"\n config = pipeline_pb2.TrainEvalPipelineConfig()\n with open(config_path, \"r\") as f:\n proto_str = f.read()\n text_format.Merge(proto_str, config)\n input_cfg = config.eval_input_reader\n model_cfg = config.model.second\n # config_tool.change_detection_range(model_cfg, [-50, -50, 50, 50])\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n # ckpt_path = \"../checkpoint/voxelnet-140670.tckpt\"\n ckpt_path=\"/home/mayank_sati/Downloads/pretrained_models_v1.5/pp_model_for_nuscenes_pretrain/voxelnet-296960.tckpt\"\n net = build_network(model_cfg).to(device).eval()\n net.load_state_dict(torch.load(ckpt_path))\n target_assigner = net.target_assigner\n self.voxel_generator = net.voxel_generator\n\n class_names = target_assigner.classes\n\n grid_size = self.voxel_generator.grid_size\n feature_map_size = grid_size[:2] // config_tool.get_downsample_factor(model_cfg)\n feature_map_size = [*feature_map_size, 1][::-1]\n anchors = target_assigner.generate_anchors(feature_map_size)[\"anchors\"]\n anchors = torch.tensor(anchors, dtype=torch.float32, device=device)\n anchors = anchors.view(1, -1, 7)\n # @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n feature_map_size = [1, 50, 50]\n ret = target_assigner.generate_anchors(feature_map_size)\n class_names = target_assigner.classes\n anchors_dict = target_assigner.generate_anchors_dict(feature_map_size)\n anchors_list = []\n for k, v in anchors_dict.items():\n anchors_list.append(v[\"anchors\"])\n\n # anchors = ret[\"anchors\"]\n anchors = np.concatenate(anchors_list, axis=0)\n anchors = anchors.reshape([-1, target_assigner.box_ndim])\n assert np.allclose(anchors, ret[\"anchors\"].reshape(-1, target_assigner.box_ndim))\n matched_thresholds = ret[\"matched_thresholds\"]\n unmatched_thresholds = ret[\"unmatched_thresholds\"]\n # anchors_bv = box_np_ops.rbbox2d_to_near_bbox(anchors[:, [0, 1, 3, 4, 6]])\n anchors_bv = 2\n anchor_cache = {\n \"anchors\": anchors,\n \"anchors_bv\": anchors_bv,\n \"matched_thresholds\": matched_thresholds,\n \"unmatched_thresholds\": unmatched_thresholds,\n \"anchors_dict\": anchors_dict,\n }\n anchors = torch.tensor(anchors, dtype=torch.float32, device=device)\n self.anchors = anchors.view(1, -1, 7)\n self.net = net\n self.device = device\n ##########################################################################################\n # self.marker_publisher = rospy.Publisher('visualization_marker', MarkerArray, queue_size=5)\n self.pcl_publisher = rospy.Publisher('result_pcl', PointCloud2, queue_size=1)\n ############\n # [print(n.name) for n in tf.get_default_graph().as_graph_def().node]\n # ROS environment setup\n # ## Define subscribers\n self.subscribers_def()\n # ## Define publishers\n self.publishers_def()\n self.now = rospy.Time.now()\n\n # Define subscribers\n def subscribers_def(self):\n # subs_topic = '/kitti/velo/pointcloud'\n #subs_topic = '/apollo/sensor/velodyne64/compensator/PointCloud2'\n # subs_topic = '/velodyne64_points'\n\n # subs_topic = '/apollo/sensor/velodyne64/PointCloud2'\n # subs_topic = '/points_raw'\n # subs_topic = '/livox/lidar'\n # subs_topic = '/apollo/sensor/velodyne32C/compensator/PointCloud2'\n subs_topic = '/lidar_top'\n self._sub = rospy.Subscriber(subs_topic, PointCloud2, self.lidar_callback, queue_size=10, buff_size=2 ** 24)\n # mydata = rospy.Subscriber( subs_topic , PointCloud2, self.lidar_callback, queue_size=1, buff_size=2**24)\n # print(mydata)\n\n # self._sub = rospy.Subscriber( subs_topic , Image, self.lidar_callback, queue_size=1, buff_size=100)\n\n # Define publishers\n def publishers_def(self):\n self._pub = rospy.Publisher('pc_bbox_topic', Float32MultiArray, queue_size=1)\n self.pub_arr_bbox = rospy.Publisher(\"Detections\", BoundingBoxArray, queue_size=1)\n\n # Camera image callback\n def lidar_callback(self, point_cl_msg):\n arr_bbox = BoundingBoxArray()\n ############################################################################3\n # lidar = np.fromstring(point_cl_msg.data, dtype=np.float32)\n # points = lidar.reshape(-1, 4)\n # print('gotit\"')\n # pc = ros_numpy.numpify(point_cl_msg)\n # points = np.zeros((pc.shape[0], 4))\n # points[:, 0] = pc['x']\n # points[:, 1] = pc['y']\n # points[:, 2] = pc['z']\n # points[:, 3] = pc['intensity']\n # points[:, 3] /= 255\n #########################################################333\n lidar = np.fromstring(point_cl_msg.data, dtype=np.float32)\n points = lidar.reshape(-1, 4)\n points[:, 3] /= 255\n\n #######################################################################\n res = self.voxel_generator.generate(points, max_voxels=30000)\n voxels = res[\"voxels\"]\n coords = res[\"coordinates\"]\n num_points = res[\"num_points_per_voxel\"]\n num_voxels = np.array([voxels.shape[0]], dtype=np.int64)\n # print(\"voxel_generator_time\",(time.time() - t)*1000)\n ###############################################################\n # print(voxels.shape)\n # add batch idx to coords\n coords = np.pad(coords, ((0, 0), (1, 0)), mode='constant', constant_values=0)\n voxels = torch.tensor(voxels, dtype=torch.float32, device=self.device)\n coords = torch.tensor(coords, dtype=torch.int32, device=self.device)\n num_points = torch.tensor(num_points, dtype=torch.int32, device=self.device)\n # print(\"conversion time\",(time.time() - t)*1000)\n example = {\"anchors\": self.anchors, \"voxels\": voxels, \"num_points\": num_points, \"coordinates\": coords, }\n t2 = time.time()\n pred = self.net(example)[0]\n # print(pred)\n # print(\"prediction\",(time.time() - t2)*1000)\n # print(\"total_time\",(time.time() - t)*1000)\n boxes_lidar = pred[\"box3d_lidar\"].detach().cpu().numpy()\n scores_lidar = pred[\"scores\"].detach().cpu().numpy()\n labels_lidar = pred[\"label_preds\"].detach().cpu().numpy()\n ##############################3333\n threshold = 0.2\n keep = np.where((scores_lidar >= threshold))[0]\n scores_lidar = scores_lidar[keep]\n print(scores_lidar)\n boxes_lidar = boxes_lidar[keep]\n labels_lidar = labels_lidar[keep]\n # sco\n # print(scores_lidar)\n ################################################################################\n # self.show_text_in_rviz_mullti_cube(boxes_lidar,point_cl_msg)\n # self.show_text_in_rviz_mullti_sphere(boxes_lidar,point_cl_msg)\n ##################################################################################\n # apollo integration\n # numboxes = np.squeeze(scores_lidar)\n numboxes = len(scores_lidar)\n tl_bbox = Float32MultiArray()\n iLen = boxes_lidar.shape[0]\n lidar_bbox = Float32MultiArray()\n print('Processing no of object:', iLen)\n\n if (numboxes) >= 1:\n tmp = -np.ones(10 * (numboxes) + 1)\n for i in range(0, int(numboxes)):\n try:\n score = float((scores_lidar)[i])\n if (boxes_lidar.shape[0]) == 1:\n bboxes = [float(v) for v in (boxes_lidar)[i]]\n else:\n bboxes = [float(v) for v in np.squeeze(boxes_lidar)[i]]\n tmp[0] = numboxes\n tmp[10 * i + 1] = score\n tmp[10 * i + 2] = bboxes[0]\n tmp[10 * i + 3] = bboxes[1]\n tmp[10 * i + 4] = bboxes[2]\n tmp[10 * i + 5] = bboxes[3]\n tmp[10 * i + 6] = bboxes[4]\n tmp[10 * i + 7] = bboxes[5]\n tmp[10 * i + 8] = bboxes[6]\n tmp[10 * i + 9] = 0\n tmp[10 * i + 10] = 0\n bbox = BoundingBox()\n # bbox.header.frame_id = point_cl_msg.header.frame_id\n # bbox.header.frame_id = 'livox_frame'\n bbox.header.frame_id = 'lidar_top'\n q = Quaternion(axis=(0, 0, 1), radians=-1.0 * float(boxes_lidar[i][6]))\n bbox.pose.orientation.x = q.x\n bbox.pose.orientation.y = q.y\n bbox.pose.orientation.z = q.z\n bbox.pose.orientation.w = q.w\n bbox.pose.position.x = float(boxes_lidar[i][0])\n bbox.pose.position.y = float(boxes_lidar[i][1])\n bbox.pose.position.z = float(boxes_lidar[i][2])\n bbox.dimensions.x = float(boxes_lidar[i][3])\n bbox.dimensions.y = float(boxes_lidar[i][4])\n bbox.dimensions.z = float(boxes_lidar[i][5])\n arr_bbox.boxes.append(bbox)\n\n except:\n print(\"I am here\")\n # here data for publishing\n tl_bbox.data = tmp\n self._pub.publish(tl_bbox)\n arr_bbox.header.frame_id = point_cl_msg.header.frame_id\n self.pub_arr_bbox.publish(arr_bbox)\n\n point_cl_msg.header.frame_id = point_cl_msg.header.frame_id\n self.pcl_publisher.publish(point_cl_msg)\n arr_bbox.boxes.clear()\n\n\ndef spin(self):\n rospy.spin()\n\n\ndef main():\n rospy.init_node('LIDAR_NODE', anonymous=True)\n tf_ob = ros_tensorflow_obj()\n\n # tf_ob.subscribers_def\n try:\n rospy.spin()\n except KeyboardInterrupt:\n print(\"Shutting down\")\n\n\nif __name__ == '__main__':\n main()\n",
"#!/usr/bin/env python\n# ROS node libs\n\nimport time\n\nimport numpy as np\nimport rospy\nimport torch\n# from geometry_msgs.msg import Quaternion, Pose, Point, Vector3\nfrom pyquaternion import Quaternion\nfrom google.protobuf import text_format\nfrom sensor_msgs.msg import PointCloud2\nfrom std_msgs.msg import Header, ColorRGBA\n# from cv_bridge import CvBridge, CvBridgeError\nfrom visualization_msgs.msg import Marker, MarkerArray\n\nfrom second.protos import pipeline_pb2\n# from second.utils import simplevis\nfrom second.pytorch.train import build_network\nfrom second.utils import config_tool\nfrom std_msgs.msg import Int16, Float32MultiArray\nfrom jsk_recognition_msgs.msg import BoundingBox, BoundingBoxArray\n# import ros_numpy\n\n\n# GPU settings: Select GPUs to use. Coment it to let the system decide\n# os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n\nclass ros_tensorflow_obj():\n def __init__(self):\n # ## Initial msg\n rospy.loginfo(' ## Starting ROS interface ##')\n # ## Load a (frozen) Tensorflow model into memory.\n print(\"ready to process----------------------------------------------------------\")\n ####################################################################################333\n config_path = \"../configs/nuscenes/all.pp.largea.config\"\n config = pipeline_pb2.TrainEvalPipelineConfig()\n with open(config_path, \"r\") as f:\n proto_str = f.read()\n text_format.Merge(proto_str, config)\n input_cfg = config.eval_input_reader\n model_cfg = config.model.second\n # config_tool.change_detection_range(model_cfg, [-50, -50, 50, 50])\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n ckpt_path = \"../checkpoint/voxelnet-140670.tckpt\"\n net = build_network(model_cfg).to(device).eval()\n net.load_state_dict(torch.load(ckpt_path))\n target_assigner = net.target_assigner\n self.voxel_generator = net.voxel_generator\n\n class_names = target_assigner.classes\n\n grid_size = self.voxel_generator.grid_size\n feature_map_size = grid_size[:2] // config_tool.get_downsample_factor(model_cfg)\n feature_map_size = [*feature_map_size, 1][::-1]\n anchors = target_assigner.generate_anchors(feature_map_size)[\"anchors\"]\n anchors = torch.tensor(anchors, dtype=torch.float32, device=device)\n anchors = anchors.view(1, -1, 7)\n # @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n feature_map_size = [1, 50, 50]\n ret = target_assigner.generate_anchors(feature_map_size)\n class_names = target_assigner.classes\n anchors_dict = target_assigner.generate_anchors_dict(feature_map_size)\n anchors_list = []\n for k, v in anchors_dict.items():\n anchors_list.append(v[\"anchors\"])\n\n # anchors = ret[\"anchors\"]\n anchors = np.concatenate(anchors_list, axis=0)\n anchors = anchors.reshape([-1, target_assigner.box_ndim])\n assert np.allclose(anchors, ret[\"anchors\"].reshape(-1, target_assigner.box_ndim))\n matched_thresholds = ret[\"matched_thresholds\"]\n unmatched_thresholds = ret[\"unmatched_thresholds\"]\n # anchors_bv = box_np_ops.rbbox2d_to_near_bbox(anchors[:, [0, 1, 3, 4, 6]])\n anchors_bv = 2\n anchor_cache = {\n \"anchors\": anchors,\n \"anchors_bv\": anchors_bv,\n \"matched_thresholds\": matched_thresholds,\n \"unmatched_thresholds\": unmatched_thresholds,\n \"anchors_dict\": anchors_dict,\n }\n anchors = torch.tensor(anchors, dtype=torch.float32, device=device)\n self.anchors = anchors.view(1, -1, 7)\n self.net = net\n self.device = device\n ##########################################################################################\n # self.marker_publisher = rospy.Publisher('visualization_marker', MarkerArray, queue_size=5)\n # self.pcl_publisher = rospy.Publisher('result_pcl', PointCloud2, queue_size=1)\n ############\n # [print(n.name) for n in tf.get_default_graph().as_graph_def().node]\n # ROS environment setup\n # ## Define subscribers\n self.subscribers_def()\n # ## Define publishers\n self.publishers_def()\n self.now = rospy.Time.now()\n\n # Define subscribers\n def subscribers_def(self):\n # subs_topic = '/kitti/velo/pointcloud'\n #subs_topic = '/apollo/sensor/velodyne64/compensator/PointCloud2'\n # subs_topic = '/velodyne64_points'\n\n # subs_topic = '/apollo/sensor/velodyne64/PointCloud2'\n # subs_topic = '/points_raw'\n # subs_topic = '/livox/lidar'\n # subs_topic = '/apollo/sensor/velodyne32C/compensator/PointCloud2'\n subs_topic = '/lidar_top'\n self._sub = rospy.Subscriber(subs_topic, PointCloud2, self.lidar_callback, queue_size=10, buff_size=2 ** 24)\n # mydata = rospy.Subscriber( subs_topic , PointCloud2, self.lidar_callback, queue_size=1, buff_size=2**24)\n # print(mydata)\n\n # self._sub = rospy.Subscriber( subs_topic , Image, self.lidar_callback, queue_size=1, buff_size=100)\n\n # Define publishers\n def publishers_def(self):\n self._pub = rospy.Publisher('pc_bbox_topic', Float32MultiArray, queue_size=1)\n self.pub_arr_bbox = rospy.Publisher(\"Detections\", BoundingBoxArray, queue_size=1)\n\n # Camera image callback\n def lidar_callback(self, point_cl_msg):\n arr_bbox = BoundingBoxArray()\n ############################################################################3\n # lidar = np.fromstring(point_cl_msg.data, dtype=np.float32)\n # points = lidar.reshape(-1, 4)\n # print('gotit\"')\n # pc = ros_numpy.numpify(point_cl_msg)\n # points = np.zeros((pc.shape[0], 4))\n # points[:, 0] = pc['x']\n # points[:, 1] = pc['y']\n # points[:, 2] = pc['z']\n # points[:, 3] = pc['intensity']\n # points[:, 3] /= 255\n #########################################################333\n lidar = np.fromstring(point_cl_msg.data, dtype=np.float32)\n points = lidar.reshape(-1, 4)\n points[:, 3] /= 255\n\n #######################################################################\n res = self.voxel_generator.generate(points, max_voxels=30000)\n voxels = res[\"voxels\"]\n coords = res[\"coordinates\"]\n num_points = res[\"num_points_per_voxel\"]\n num_voxels = np.array([voxels.shape[0]], dtype=np.int64)\n # print(\"voxel_generator_time\",(time.time() - t)*1000)\n ###############################################################\n # print(voxels.shape)\n # add batch idx to coords\n coords = np.pad(coords, ((0, 0), (1, 0)), mode='constant', constant_values=0)\n voxels = torch.tensor(voxels, dtype=torch.float32, device=self.device)\n coords = torch.tensor(coords, dtype=torch.int32, device=self.device)\n num_points = torch.tensor(num_points, dtype=torch.int32, device=self.device)\n # print(\"conversion time\",(time.time() - t)*1000)\n example = {\"anchors\": self.anchors, \"voxels\": voxels, \"num_points\": num_points, \"coordinates\": coords, }\n t2 = time.time()\n pred = self.net(example)[0]\n # print(pred)\n # print(\"prediction\",(time.time() - t2)*1000)\n # print(\"total_time\",(time.time() - t)*1000)\n boxes_lidar = pred[\"box3d_lidar\"].detach().cpu().numpy()\n scores_lidar = pred[\"scores\"].detach().cpu().numpy()\n labels_lidar = pred[\"label_preds\"].detach().cpu().numpy()\n ##############################3333\n threshold = .3\n keep = np.where((scores_lidar >= threshold))[0]\n scores_lidar = scores_lidar[keep]\n print(scores_lidar)\n boxes_lidar = boxes_lidar[keep]\n labels_lidar = labels_lidar[keep]\n # sco\n # print(scores_lidar)\n ################################################################################\n # self.show_text_in_rviz_mullti_cube(boxes_lidar,point_cl_msg)\n # self.show_text_in_rviz_mullti_sphere(boxes_lidar,point_cl_msg)\n ##################################################################################\n # apollo integration\n # numboxes = np.squeeze(scores_lidar)\n numboxes = len(scores_lidar)\n tl_bbox = Float32MultiArray()\n iLen = boxes_lidar.shape[0]\n lidar_bbox = Float32MultiArray()\n print('Processing no of object:', iLen)\n\n if (numboxes) >= 1:\n tmp = -np.ones(10 * (numboxes) + 1)\n for i in range(0, int(numboxes)):\n try:\n score = float((scores_lidar)[i])\n if (boxes_lidar.shape[0]) == 1:\n bboxes = [float(v) for v in (boxes_lidar)[i]]\n else:\n bboxes = [float(v) for v in np.squeeze(boxes_lidar)[i]]\n tmp[0] = numboxes\n tmp[10 * i + 1] = score\n tmp[10 * i + 2] = bboxes[0]\n tmp[10 * i + 3] = bboxes[1]\n tmp[10 * i + 4] = bboxes[2]\n tmp[10 * i + 5] = bboxes[3]\n tmp[10 * i + 6] = bboxes[4]\n tmp[10 * i + 7] = bboxes[5]\n tmp[10 * i + 8] = bboxes[6]\n tmp[10 * i + 9] = 0\n tmp[10 * i + 10] = 0\n bbox = BoundingBox()\n # bbox.header.frame_id = point_cl_msg.header.frame_id\n # bbox.header.frame_id = 'livox_frame'\n bbox.header.frame_id = 'lidar_top'\n q = Quaternion(axis=(0, 0, 1), radians=-1.0 * float(boxes_lidar[i][6]))\n bbox.pose.orientation.x = q.x\n bbox.pose.orientation.y = q.y\n bbox.pose.orientation.z = q.z\n bbox.pose.orientation.w = q.w\n bbox.pose.position.x = float(boxes_lidar[i][0])\n bbox.pose.position.y = float(boxes_lidar[i][1])\n bbox.pose.position.z = float(boxes_lidar[i][2])\n bbox.dimensions.x = float(boxes_lidar[i][3])\n bbox.dimensions.y = float(boxes_lidar[i][4])\n bbox.dimensions.z = float(boxes_lidar[i][5])\n arr_bbox.boxes.append(bbox)\n\n except:\n print(\"I am here\")\n # here data for publishing\n tl_bbox.data = tmp\n self._pub.publish(tl_bbox)\n arr_bbox.header.frame_id = point_cl_msg.header.frame_id\n self.pub_arr_bbox.publish(arr_bbox)\n arr_bbox.boxes.clear()\n\n\ndef spin(self):\n rospy.spin()\n\n\ndef main():\n rospy.init_node('LIDAR_NODE', anonymous=True)\n tf_ob = ros_tensorflow_obj()\n\n # tf_ob.subscribers_def\n try:\n rospy.spin()\n except KeyboardInterrupt:\n print(\"Shutting down\")\n\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"numpy.concatenate",
"numpy.pad",
"numpy.array",
"numpy.ones",
"numpy.where",
"torch.cuda.is_available",
"torch.tensor",
"torch.load",
"numpy.fromstring",
"numpy.squeeze"
],
[
"numpy.concatenate",
"numpy.pad",
"numpy.array",
"numpy.ones",
"numpy.where",
"torch.cuda.is_available",
"torch.tensor",
"torch.load",
"numpy.fromstring",
"numpy.squeeze"
]
] |
MaxSchambach/colour | [
"3f3685d616fda4be58cec20bc1e16194805d7e2d",
"3f3685d616fda4be58cec20bc1e16194805d7e2d",
"3f3685d616fda4be58cec20bc1e16194805d7e2d",
"3f3685d616fda4be58cec20bc1e16194805d7e2d",
"3f3685d616fda4be58cec20bc1e16194805d7e2d"
] | [
"colour/corresponding/datasets/breneman1987.py",
"colour/models/rgb/transfer_functions/itur_bt_1886.py",
"colour/volume/tests/test_mesh.py",
"colour/utilities/common.py",
"colour/appearance/llab.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nBreneman Corresponding Chromaticities Dataset\n=============================================\n\nDefines *Breneman (1987)* results for corresponding chromaticities experiments.\n\nSee Also\n--------\n`Corresponding Chromaticities Prediction Jupyter Notebook\n<http://nbviewer.jupyter.org/github/colour-science/colour-notebooks/\\\nblob/master/notebooks/corresponding/prediction.ipynb>`_\n\nReferences\n----------\n- :cite:`Breneman1987b` : Breneman, E. J. (1987). Corresponding\n chromaticities for different states of adaptation to complex visual fields.\n Journal of the Optical Society of America A, 4(6), 1115.\n doi:10.1364/JOSAA.4.001115\n\"\"\"\n\nfrom __future__ import division, unicode_literals\n\nimport numpy as np\n\nfrom collections import namedtuple\n\nfrom colour.utilities.documentation import DocstringDict\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2019 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = '[email protected]'\n__status__ = 'Production'\n\n__all__ = [\n 'BrenemanExperimentResult', 'PrimariesChromaticityCoordinates',\n 'BRENEMAN_EXPERIMENT_1_RESULTS', 'BRENEMAN_EXPERIMENT_2_RESULTS',\n 'BRENEMAN_EXPERIMENT_3_RESULTS', 'BRENEMAN_EXPERIMENT_4_RESULTS',\n 'BRENEMAN_EXPERIMENT_5_RESULTS', 'BRENEMAN_EXPERIMENT_6_RESULTS',\n 'BRENEMAN_EXPERIMENT_7_RESULTS', 'BRENEMAN_EXPERIMENT_10_RESULTS',\n 'BRENEMAN_EXPERIMENT_8_RESULTS', 'BRENEMAN_EXPERIMENT_9_RESULTS',\n 'BRENEMAN_EXPERIMENT_11_RESULTS', 'BRENEMAN_EXPERIMENT_12_RESULTS',\n 'BRENEMAN_EXPERIMENTS_PRIMARIES_CHROMATICITIES', 'BRENEMAN_EXPERIMENTS'\n]\n\n\nclass BrenemanExperimentResult(\n namedtuple('BrenemanExperimentResult',\n ('name', 'uv_t', 'uv_m', 's_uv', 'd_uv_i', 'd_uv_g'))):\n \"\"\"\n Experiment result.\n\n Parameters\n ----------\n name : unicode\n Test colour name.\n uv_t : numeric\n Chromaticity coordinates :math:`uv_t^p` of test colour.\n uv_m : array_like, (2,)\n Chromaticity coordinates :math:`uv_m^p` of matching colour.\n s_uv : array_like, (2,), optional\n Interobserver variation (:math:`x10^3`) :math:`\\\\sigma_uv^p`.\n d_uv_i : array_like, (2,), optional\n Deviation of individual linear transformation (:math:`x10^3`)\n :math:`\\\\delta_uv_i^p`.\n d_uv_g : array_like, (2,), optional\n Deviation of individual linear transformation (:math:`x10^3`)\n :math:`\\\\delta_uv_g^p`.\n \"\"\"\n\n def __new__(cls, name, uv_t, uv_m, s_uv=None, d_uv_i=None, d_uv_g=None):\n \"\"\"\n Returns a new instance of the\n :class:`colour.corresponding.datasets.corresponding_chromaticities.\\\nBrenemanExperimentResult` class.\n \"\"\"\n\n return super(BrenemanExperimentResult, cls).__new__(\n cls, name, np.array(uv_t), np.array(uv_m), np.array(s_uv),\n np.array(d_uv_i), np.array(d_uv_g))\n\n\nclass PrimariesChromaticityCoordinates(\n namedtuple(\n 'PrimariesChromaticityCoordinates',\n ('experiment', 'illuminants', 'Y', 'P_uvp', 'D_uvp', 'T_uvp'))):\n \"\"\"\n Chromaticity coordinates of primaries.\n\n Parameters\n ----------\n experiment : integer\n Experiment.\n illuminants : array_like, (2,)\n Chromaticity coordinates :math:`uv_t^p` of test colour.\n Y : numeric\n White luminance :math:`Y` in :math:`cd/m^2`.\n P_uvp : numeric\n Chromaticity coordinates :math:`uv^p` of primary :math:`P`.\n D_uvp : numeric\n Chromaticity coordinates :math:`uv^p` of primary :math:`D`.\n T_uvp : numeric\n Chromaticity coordinates :math:`uv^p` of primary :math:`T`.\n \"\"\"\n\n def __new__(cls,\n experiment,\n illuminants,\n Y,\n P_uvp=None,\n D_uvp=None,\n T_uvp=None):\n \"\"\"\n Returns a new instance of the\n :class:`colour.corresponding.datasets.corresponding_chromaticities.\\\nPrimariesChromaticityCoordinates` class.\n \"\"\"\n\n return super(PrimariesChromaticityCoordinates, cls).__new__(\n cls, experiment, np.array(illuminants), np.array(Y),\n np.array(P_uvp), np.array(D_uvp), np.array(T_uvp))\n\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_1_RESULTS = (\n BrenemanExperimentResult(\n 'Illuminant',\n (0.259, 0.526), (0.200, 0.475)),\n BrenemanExperimentResult(\n 'Gray',\n (0.259, 0.524), (0.199, 0.487), (4, 4), (2, 3), (0, 0)),\n BrenemanExperimentResult(\n 'Red',\n (0.459, 0.522), (0.420, 0.509), (19, 4), (-10, -7), (-19, -3)),\n BrenemanExperimentResult(\n 'Skin',\n (0.307, 0.526), (0.249, 0.497), (7, 4), (-1, 1), (-6, -1)),\n BrenemanExperimentResult(\n 'Orange',\n (0.360, 0.544), (0.302, 0.548), (12, 1), (1, -2), (-7, -6)),\n BrenemanExperimentResult(\n 'Brown',\n (0.350, 0.541), (0.290, 0.537), (11, 4), (3, 0), (-5, -3)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.318, 0.550), (0.257, 0.554), (8, 2), (0, 2), (-5, -5)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.258, 0.542), (0.192, 0.529), (4, 6), (3, 2), (3, -6)),\n BrenemanExperimentResult(\n 'Green',\n (0.193, 0.542), (0.129, 0.521), (7, 5), (3, 2), (9, -7)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.180, 0.516), (0.133, 0.469), (4, 6), (-3, -2), (2, -5)),\n BrenemanExperimentResult(\n 'Blue',\n (0.186, 0.445), (0.158, 0.340), (13, 33), (2, 7), (1, 13)),\n BrenemanExperimentResult(\n 'Sky',\n (0.226, 0.491), (0.178, 0.426), (3, 14), (1, -3), (0, -1)),\n BrenemanExperimentResult(\n 'Purple',\n (0.278, 0.456), (0.231, 0.365), (4, 25), (0, 2), (-5, 7)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 1 results.\n\nBRENEMAN_EXPERIMENT_1_RESULTS : tuple\n\nNotes\n-----\n- Illuminants : *A*, *D65*\n- White Luminance : 1500 :math:`cd/m^2`\n- Observers Count : 7\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_2_RESULTS = (\n BrenemanExperimentResult(\n 'Illuminant',\n (0.222, 0.521), (0.204, 0.479)),\n BrenemanExperimentResult(\n 'Gray',\n (0.227, 0.517), (0.207, 0.486), (2, 5), (-1, 0), (0, 0)),\n BrenemanExperimentResult(\n 'Red',\n (0.464, 0.520), (0.449, 0.511), (22, 3), (-8, -8), (-7, -2)),\n BrenemanExperimentResult(\n 'Skin',\n (0.286, 0.526), (0.263, 0.505), (7, 2), (0, -1), (0, -1)),\n BrenemanExperimentResult(\n 'Orange',\n (0.348, 0.546), (0.322, 0.545), (13, 3), (3, -1), (3, -2)),\n BrenemanExperimentResult(\n 'Brown',\n (0.340, 0.543), (0.316, 0.537), (11, 3), (1, 1), (0, 0)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.288, 0.554), (0.265, 0.553), (5, 2), (-2, 2), (-1, -2)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.244, 0.547), (0.221, 0.538), (4, 3), (-2, 1), (0, -3)),\n BrenemanExperimentResult(\n 'Green',\n (0.156, 0.548), (0.135, 0.532), (4, 3), (-1, 3), (3, -4)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.159, 0.511), (0.145, 0.472), (9, 7), (-1, 2), (2, 1)),\n BrenemanExperimentResult(\n 'Blue',\n (0.160, 0.406), (0.163, 0.331), (23, 31), (2, -3), (-1, 3)),\n BrenemanExperimentResult(\n 'Sky',\n (0.190, 0.481), (0.176, 0.431), (5, 24), (2, -2), (2, 0)),\n BrenemanExperimentResult(\n 'Purple',\n (0.258, 0.431), (0.244, 0.349), (4, 19), (-3, 13), (-4, 19)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 2 results.\n\nBRENEMAN_EXPERIMENT_2_RESULTS : tuple\n\nNotes\n-----\n- Illuminants : *Projector*, *D55*\n- White Luminance : 1500 :math:`cd/m^2`\n- Observers Count : 7\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_3_RESULTS = (\n BrenemanExperimentResult(\n 'Illuminant',\n (0.223, 0.521), (0.206, 0.478)),\n BrenemanExperimentResult(\n 'Gray',\n (0.228, 0.517), (0.211, 0.494), (1, 3), (0, 2), (0, 0)),\n BrenemanExperimentResult(\n 'Red',\n (0.462, 0.519), (0.448, 0.505), (11, 4), (-3, 6), (-4, 6)),\n BrenemanExperimentResult(\n 'Skin',\n (0.285, 0.524), (0.267, 0.507), (6, 3), (-1, 1), (-2, 1)),\n BrenemanExperimentResult(\n 'Orange',\n (0.346, 0.546), (0.325, 0.541), (11, 3), (1, -2), (2, 3)),\n BrenemanExperimentResult(\n 'Brown',\n (0.338, 0.543), (0.321, 0.532), (9, 6), (-3, 2), (-3, 7)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.287, 0.554), (0.267, 0.548), (4, 5), (1, -2), (0, 5)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.244, 0.547), (0.226, 0.531), (3, 6), (-1, 3), (-2, 8)),\n BrenemanExperimentResult(\n 'Green',\n (0.157, 0.548), (0.141, 0.528), (9, 6), (2, 2), (0, 6)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.160, 0.510), (0.151, 0.486), (8, 5), (-2, -1), (-2, -5)),\n BrenemanExperimentResult(\n 'Blue',\n (0.162, 0.407), (0.158, 0.375), (6, 7), (1, -6), (4, -23)),\n BrenemanExperimentResult(\n 'Sky',\n (0.191, 0.482), (0.179, 0.452), (4, 5), (0, 1), (1, -7)),\n BrenemanExperimentResult(\n 'Purple',\n (0.258, 0.432), (0.238, 0.396), (4, 8), (5, 3), (4, -11)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 3 results.\n\nBRENEMAN_EXPERIMENT_3_RESULTS : tuple\n\nNotes\n-----\n- Illuminants : *Projector*, *D55*\n- White Luminance : 75 :math:`cd/m^2`\n- Observers Count : 7\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_4_RESULTS = (\n BrenemanExperimentResult(\n 'Illuminant',\n (0.258, 0.523), (0.199, 0.467)),\n BrenemanExperimentResult(\n 'Gray',\n (0.257, 0.524), (0.205, 0.495), (2, 2), (0, 4), (0, 0)),\n BrenemanExperimentResult(\n 'Red',\n (0.460, 0.521), (0.416, 0.501), (11, 6), (-6, 4), (-6, 9)),\n BrenemanExperimentResult(\n 'Skin',\n (0.308, 0.526), (0.253, 0.503), (7, 3), (-1, 1), (-1, 0)),\n BrenemanExperimentResult(\n 'Orange',\n (0.360, 0.544), (0.303, 0.541), (14, 5), (1, -4), (1, 2)),\n BrenemanExperimentResult(\n 'Brown',\n (0.350, 0.541), (0.296, 0.527), (11, 7), (-2, 4), (-3, 9)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.317, 0.550), (0.260, 0.547), (9, 5), (1, -3), (0, 3)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.258, 0.543), (0.203, 0.520), (4, 6), (0, 8), (0, 9)),\n BrenemanExperimentResult(\n 'Green',\n (0.193, 0.543), (0.142, 0.516), (6, 9), (3, 8), (2, 6)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.180, 0.516), (0.140, 0.484), (9, 5), (-2, -1), (-1, -9)),\n BrenemanExperimentResult(\n 'Blue',\n (0.185, 0.445), (0.151, 0.394), (8, 10), (2, -8), (8, -24)),\n BrenemanExperimentResult(\n 'Sky',\n (0.225, 0.490), (0.180, 0.448), (4, 8), (1, -1), (3, -11)),\n BrenemanExperimentResult(\n 'Purple',\n (0.278, 0.455), (0.229, 0.388), (6, 14), (1, 12), (3, 0)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 4 results.\n\nBRENEMAN_EXPERIMENT_4_RESULTS : tuple\n\nNotes\n-----\n- Illuminants : *A*, *D65*\n- White Luminance : 75 :math:`cd/m^2`\n- Observers Count : 7\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_5_RESULTS = (\n BrenemanExperimentResult(\n 'Gray',\n (0.028, 0.480), (0.212, 0.491), (2, 2)),\n BrenemanExperimentResult(\n 'Red',\n (0.449, 0.512), (0.408, 0.514), (11, 5)),\n BrenemanExperimentResult(\n 'Skin',\n (0.269, 0.505), (0.262, 0.511), (4, 2)),\n BrenemanExperimentResult(\n 'Orange',\n (0.331, 0.548), (0.303, 0.545), (4, 3)),\n BrenemanExperimentResult(\n 'Brown',\n (0.322, 0.541), (0.303, 0.538), (4, 4)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.268, 0.555), (0.264, 0.550), (3, 2)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.224, 0.538), (0.227, 0.535), (3, 3)),\n BrenemanExperimentResult(\n 'Green',\n (0.134, 0.531), (0.159, 0.530), (9, 3)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.145, 0.474), (0.165, 0.490), (8, 3)),\n BrenemanExperimentResult(\n 'Blue',\n (0.163, 0.329), (0.173, 0.378), (7, 12)),\n BrenemanExperimentResult(\n 'Sky',\n (0.179, 0.438), (0.189, 0.462), (5, 4)),\n BrenemanExperimentResult(\n 'Purple',\n (0.245, 0.364), (0.239, 0.401), (4, 16)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 5 results.\n\nBRENEMAN_EXPERIMENT_5_RESULTS : tuple\n\nNotes\n-----\n- Effective White Levels : 130 and 2120 :math:`cd/m^2`\n- Observers Count : 7\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_6_RESULTS = (\n BrenemanExperimentResult(\n 'Illuminant',\n (0.257, 0.525), (0.201, 0.482)),\n BrenemanExperimentResult(\n 'Gray',\n (0.267, 0.521), (0.207, 0.485), (5, 3), (-1, 0), (0, 0)),\n BrenemanExperimentResult(\n 'Red',\n (0.457, 0.521), (0.398, 0.516), (9, 4), (-2, -5), (1, -9)),\n BrenemanExperimentResult(\n 'Skin',\n (0.316, 0.526), (0.253, 0.503), (5, 3), (-3, -2), (-1, -3)),\n BrenemanExperimentResult(\n 'Orange',\n (0.358, 0.545), (0.287, 0.550), (7, 3), (3, 0), (7, -6)),\n BrenemanExperimentResult(\n 'Brown',\n (0.350, 0.541), (0.282, 0.540), (6, 3), (-1, 0), (2, -5)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.318, 0.551), (0.249, 0.556), (7, 2), (-1, 1), (2, -5)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.256, 0.547), (0.188, 0.537), (5, 4), (3, 1), (4, -2)),\n BrenemanExperimentResult(\n 'Green',\n (0.193, 0.542), (0.133, 0.520), (13, 3), (5, -2), (5, -4)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.180, 0.516), (0.137, 0.466), (12, 10), (0, 0), (-2, 2)),\n BrenemanExperimentResult(\n 'Blue',\n (0.186, 0.445), (0.156, 0.353), (12, 45), (6, 1), (2, 6)),\n BrenemanExperimentResult(\n 'Sky',\n (0.225, 0.492), (0.178, 0.428), (6, 14), (1, -1), (-1, 3)),\n BrenemanExperimentResult(\n 'Purple',\n (0.276, 0.456), (0.227, 0.369), (6, 27), (-2, 4), (-3, 9)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 6 results.\n\nBRENEMAN_EXPERIMENT_6_RESULTS : tuple\n\nNotes\n-----\n- Illuminants : *A*, *D55*\n- White Luminance : 11100 :math:`cd/m^2`\n- Observers Count : 8\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_7_RESULTS = (\n BrenemanExperimentResult(\n 'Gray',\n (0.208, 0.481), (0.211, 0.486), (2, 3)),\n BrenemanExperimentResult(\n 'Red',\n (0.448, 0.512), (0.409, 0.516), (9, 2)),\n BrenemanExperimentResult(\n 'Skin',\n (0.269, 0.505), (0.256, 0.506), (4, 3)),\n BrenemanExperimentResult(\n 'Orange',\n (0.331, 0.549), (0.305, 0.547), (5, 4)),\n BrenemanExperimentResult(\n 'Brown',\n (0.322, 0.541), (0.301, 0.539), (5, 2)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.268, 0.555), (0.257, 0.552), (3, 4)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.225, 0.538), (0.222, 0.536), (3, 2)),\n BrenemanExperimentResult(\n 'Green',\n (0.135, 0.531), (0.153, 0.529), (8, 2)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.145, 0.475), (0.160, 0.484), (3, 5)),\n BrenemanExperimentResult(\n 'Blue',\n (0.163, 0.331), (0.171, 0.379), (4, 11)),\n BrenemanExperimentResult(\n 'Sky',\n (0.179, 0.438), (0.187, 0.452), (4, 7)),\n BrenemanExperimentResult(\n 'Purple',\n (0.245, 0.365), (0.240, 0.398), (4, 10)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 7 results.\n\nBRENEMAN_EXPERIMENT_7_RESULTS : tuple\n\nNotes\n-----\n- Effective White Levels : 850 and 11100 :math:`cd/m^2`\n- Observers Count : 8\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_8_RESULTS = (\n BrenemanExperimentResult(\n 'Illuminant',\n (0.258, 0.524), (0.195, 0.469)),\n BrenemanExperimentResult(\n 'Gray',\n (0.257, 0.525), (0.200, 0.494), (2, 3), (1, 2), (0, 0)),\n BrenemanExperimentResult(\n 'Red',\n (0.458, 0.522), (0.410, 0.508), (12, 4), (-3, 5), (-7, 2)),\n BrenemanExperimentResult(\n 'Skin',\n (0.308, 0.526), (0.249, 0.502), (6, 2), (-1, 1), (-3, -1)),\n BrenemanExperimentResult(\n 'Orange',\n (0.359, 0.545), (0.299, 0.545), (12, 4), (0, -2), (-3, 0)),\n BrenemanExperimentResult(\n 'Brown',\n (0.349, 0.540), (0.289, 0.532), (10, 4), (0, 1), (-2, 2)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.317, 0.550), (0.256, 0.549), (9, 5), (0, -3), (-3, 1)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.260, 0.545), (0.198, 0.529), (5, 5), (3, 1), (0, 3)),\n BrenemanExperimentResult(\n 'Green',\n (0.193, 0.543), (0.137, 0.520), (9, 5), (3, 0), (2, 1)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.182, 0.516), (0.139, 0.477), (9, 4), (-3, 0), (-2, -4)),\n BrenemanExperimentResult(\n 'Blue',\n (0.184, 0.444), (0.150, 0.387), (5, 11), (3, -10), (6, -22)),\n BrenemanExperimentResult(\n 'Sky',\n (0.224, 0.489), (0.177, 0.439), (5, 6), (1, 1), (1, -7)),\n BrenemanExperimentResult(\n 'Purple',\n (0.277, 0.454), (0.226, 0.389), (4, 10), (1, 4), (1, -8)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 8 results.\n\nBRENEMAN_EXPERIMENT_8_RESULTS : tuple\n\nNotes\n-----\n- Illuminants : *A*, *D65*\n- White Luminance : 350 :math:`cd/m^2`\n- Observers Count : 8\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_9_RESULTS = (\n BrenemanExperimentResult(\n 'Illuminant',\n (0.254, 0.525), (0.195, 0.465)),\n BrenemanExperimentResult(\n 'Gray',\n (0.256, 0.524), (0.207, 0.496), (4, 6), (3, 2), (0, 0)),\n BrenemanExperimentResult(\n 'Red',\n (0.459, 0.521), (0.415, 0.489), (20, 14), (2, 12), (-2, 21)),\n BrenemanExperimentResult(\n 'Skin',\n (0.307, 0.525), (0.261, 0.500), (7, 7), (0, 1), (-5, 2)),\n BrenemanExperimentResult(\n 'Orange',\n (0.359, 0.545), (0.313, 0.532), (7, 5), (-2, -3), (-6, 13)),\n BrenemanExperimentResult(\n 'Brown',\n (0.349, 0.540), (0.302, 0.510), (11, 15), (0, 12), (-5, 24)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.317, 0.550), (0.268, 0.538), (7, 10), (1, -4), (-4, 12)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.259, 0.544), (0.212, 0.510), (10, 11), (0, 14), (-4, 22)),\n BrenemanExperimentResult(\n 'Green',\n (0.193, 0.542), (0.150, 0.506), (6, 10), (-1, 13), (-2, 15)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.181, 0.517), (0.144, 0.487), (9, 6), (-3, 0), (-1, -9)),\n BrenemanExperimentResult(\n 'Blue',\n (0.184, 0.444), (0.155, 0.407), (4, 11), (-2, -6), (6, -36)),\n BrenemanExperimentResult(\n 'Sky',\n (0.225, 0.490), (0.183, 0.458), (5, 8), (1, -3), (2, -19)),\n BrenemanExperimentResult(\n 'Purple',\n (0.276, 0.454), (0.233, 0.404), (7, 12), (2, 9), (0, -16)),\n BrenemanExperimentResult(\n '(Gray)h',\n (0.256, 0.525), (0.208, 0.498)),\n BrenemanExperimentResult(\n '(Red)h',\n (0.456, 0.521), (0.416, 0.501), (15, 7), None, (-6, -9)),\n BrenemanExperimentResult(\n '(Brown)h',\n (0.349, 0.539), (0.306, 0.526), (11, 8), None, (-8, 7)),\n BrenemanExperimentResult(\n '(Foliage)h',\n (0.260, 0.545), (0.213, 0.528), (7, 9), None, (-4, 5)),\n BrenemanExperimentResult(\n '(Green)h',\n (0.193, 0.543), (0.149, 0.525), (10, 8), None, (-1, -1)),\n BrenemanExperimentResult(\n '(Blue)h',\n (0.184, 0.444), (0.156, 0.419), (7, 8), None, (4, -45)),\n BrenemanExperimentResult(\n '(Purple)h',\n (0.277, 0.456), (0.236, 0.422), (6, 11), None, (-2, -29)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 9 results.\n\nBRENEMAN_EXPERIMENT_9_RESULTS : tuple\n\nNotes\n-----\n- Illuminants : *A*, *D65*\n- White Luminance : 15 :math:`cd/m^2`\n- Observers Count : 8\n- The colors indicated by (.)h are the darker colors presented at the higher\n luminescence level of the lighter colors.\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_10_RESULTS = (\n BrenemanExperimentResult(\n 'Gray',\n (0.208, 0.482), (0.213, 0.494), (3, 3)),\n BrenemanExperimentResult(\n 'Red',\n (0.447, 0.512), (0.411, 0.506), (15, 7)),\n BrenemanExperimentResult(\n 'Skin',\n (0.269, 0.505), (0.269, 0.511), (4, 3)),\n BrenemanExperimentResult(\n 'Orange',\n (0.331, 0.549), (0.315, 0.536), (7, 8)),\n BrenemanExperimentResult(\n 'Brown',\n (0.323, 0.542), (0.310, 0.526), (6, 8)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.268, 0.556), (0.268, 0.541), (3, 6)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.226, 0.538), (0.230, 0.525), (4, 8)),\n BrenemanExperimentResult(\n 'Green',\n (0.135, 0.531), (0.158, 0.524), (6, 3)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.145, 0.476), (0.161, 0.491), (4, 4)),\n BrenemanExperimentResult(\n 'Blue',\n (0.163, 0.330), (0.171, 0.377), (6, 19)),\n BrenemanExperimentResult(\n 'Sky',\n (0.179, 0.439), (0.187, 0.465), (5, 5)),\n BrenemanExperimentResult(\n 'Purple',\n (0.245, 0.366), (0.240, 0.402), (3, 12)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 10 results.\n\nBRENEMAN_EXPERIMENT_10_RESULTS : tuple\n\nNotes\n-----\n- Effective White Levels : 15 and 270 :math:`cd/m^2`\n- Observers Count : 7\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_11_RESULTS = (\n BrenemanExperimentResult(\n 'Illuminant',\n (0.208, 0.482), (0.174, 0.520)),\n BrenemanExperimentResult(\n 'Gray',\n (0.209, 0.483), (0.176, 0.513), (3, 4), (2, 2), (0, 0)),\n BrenemanExperimentResult(\n 'Red',\n (0.450, 0.512), (0.419, 0.524), (10, 2), (3, 2), (8, -1)),\n BrenemanExperimentResult(\n 'Skin',\n (0.268, 0.506), (0.240, 0.528), (6, 2), (-4, 0), (-3, 0)),\n BrenemanExperimentResult(\n 'Orange',\n (0.331, 0.547), (0.293, 0.553), (6, 2), (3, -1), (5, 1)),\n BrenemanExperimentResult(\n 'Brown',\n (0.323, 0.542), (0.290, 0.552), (5, 2), (-1, -3), (0, -1)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.266, 0.549), (0.236, 0.557), (4, 2), (-3, -2), (-4, 2)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.227, 0.538), (0.194, 0.552), (4, 2), (2, -3), (-1, 1)),\n BrenemanExperimentResult(\n 'Green',\n (0.146, 0.534), (0.118, 0.551), (8, 3), (4, -2), (-6, 3)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.160, 0.475), (0.130, 0.513), (9, 4), (1, -1), (-4, -3)),\n BrenemanExperimentResult(\n 'Blue',\n (0.177, 0.340), (0.133, 0.427), (6, 14), (4, -17), (11, -29)),\n BrenemanExperimentResult(\n 'Sky',\n (0.179, 0.438), (0.146, 0.482), (6, 10), (1, 4), (0, -1)),\n BrenemanExperimentResult(\n 'Purple',\n (0.245, 0.366), (0.216, 0.419), (4, 13), (-3, 8), (4, -2)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 1 results.\n\nBRENEMAN_EXPERIMENT_11_RESULTS : tuple\n\nNotes\n-----\n- Illuminants : *green*, *D65*\n- White Luminance : 1560 :math:`cd/m^2`\n- Observers Count : 7\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENT_12_RESULTS = (\n BrenemanExperimentResult(\n 'Illuminant',\n (0.205, 0.482), (0.174, 0.519)),\n BrenemanExperimentResult(\n 'Gray',\n (0.208, 0.482), (0.181, 0.507), (4, 3), (0, 1), (0, 0)),\n BrenemanExperimentResult(\n 'Red',\n (0.451, 0.512), (0.422, 0.526), (20, 3), (0, -5), (10, -5)),\n BrenemanExperimentResult(\n 'Skin',\n (0.268, 0.506), (0.244, 0.525), (5, 2), (-6, 0), (-2, -1)),\n BrenemanExperimentResult(\n 'Orange',\n (0.331, 0.548), (0.292, 0.553), (10, 2), (5, 2), (11, 1)),\n BrenemanExperimentResult(\n 'Brown',\n (0.324, 0.542), (0.286, 0.554), (8, 1), (5, -3), (10, -4)),\n BrenemanExperimentResult(\n 'Yellow',\n (0.266, 0.548), (0.238, 0.558), (6, 2), (-3, -1), (-1, -2)),\n BrenemanExperimentResult(\n 'Foliage',\n (0.227, 0.538), (0.196, 0.555), (6, 3), (3, -4), (2, -5)),\n BrenemanExperimentResult(\n 'Green',\n (0.145, 0.534), (0.124, 0.551), (8, 6), (1, -1), (-8, -1)),\n BrenemanExperimentResult(\n 'Blue-green',\n (0.160, 0.474), (0.135, 0.505), (5, 2), (1, -1), (-4, -3)),\n BrenemanExperimentResult(\n 'Blue',\n (0.178, 0.339), (0.149, 0.392), (4, 20), (-1, -5), (3, -7)),\n BrenemanExperimentResult(\n 'Sky',\n (0.179, 0.440), (0.150, 0.473), (4, 8), (3, 2), (2, 0)),\n BrenemanExperimentResult(\n 'Purple',\n (0.246, 0.366), (0.222, 0.404), (5, 15), (-4, 2), (4, 2)))\n# yapf: enable\n\"\"\"\n*Breneman (1987)* experiment 12 results.\n\nBRENEMAN_EXPERIMENT_12_RESULTS : tuple\n\nNotes\n-----\n- Illuminants : *D55*, *green*\n- White Luminance : 75 :math:`cd/m^2`\n- Observers Count : 7\n\"\"\"\n\n# yapf: disable\nBRENEMAN_EXPERIMENTS_PRIMARIES_CHROMATICITIES = DocstringDict({\n 1: PrimariesChromaticityCoordinates(\n 1, ('A', 'D65'), 1500,\n (0.671, 0.519), (-0.586, 0.627), (0.253, 0.016)),\n 2: PrimariesChromaticityCoordinates(\n 2, ('Projector', 'D55'), 1500,\n (0.675, 0.523), (-0.466, 0.617), (0.255, 0.018)),\n 3: PrimariesChromaticityCoordinates(\n 3, ('Projector', 'D55'), 75,\n (0.664, 0.510), (-0.256, 0.729), (0.244, 0.003)),\n 4: PrimariesChromaticityCoordinates(\n 4, ('A', 'D65'), 75,\n (0.674, 0.524), (-0.172, 0.628), (0.218, -0.026)),\n 6: PrimariesChromaticityCoordinates(\n 6, ('A', 'D55'), 11100,\n (0.659, 0.506), (-0.141, 0.615), (0.249, 0.009)),\n 8: PrimariesChromaticityCoordinates(\n 8, ('A', 'D65'), 350,\n (0.659, 0.505), (-0.246, 0.672), (0.235, -0.006)),\n 9: PrimariesChromaticityCoordinates(\n 9, ('A', 'D65'), 15,\n (0.693, 0.546), (-0.446, 0.773), (0.221, -0.023)),\n 11: PrimariesChromaticityCoordinates(\n 11, ('D55', 'green'), 1560,\n (0.680, 0.529), (0.018, 0.576), (0.307, 0.080)),\n 12: PrimariesChromaticityCoordinates(\n 12, ('D55', 'green'), 75,\n (0.661, 0.505), (0.039, 0.598), (0.345, 0.127))})\n# yapf: enable\nBRENEMAN_EXPERIMENTS_PRIMARIES_CHROMATICITIES.__doc__ = \"\"\"\n*Breneman (1987)* experiments primaries chromaticities.\n\nReferences\n----------\n:cite:`Breneman1987b`\n\nBRENEMAN_EXPERIMENTS_PRIMARIES_CHROMATICITIES : dict\n\"\"\"\n\nBRENEMAN_EXPERIMENTS = DocstringDict({\n 1: BRENEMAN_EXPERIMENT_1_RESULTS,\n 2: BRENEMAN_EXPERIMENT_2_RESULTS,\n 3: BRENEMAN_EXPERIMENT_3_RESULTS,\n 4: BRENEMAN_EXPERIMENT_4_RESULTS,\n 5: BRENEMAN_EXPERIMENT_5_RESULTS,\n 6: BRENEMAN_EXPERIMENT_6_RESULTS,\n 7: BRENEMAN_EXPERIMENT_7_RESULTS,\n 8: BRENEMAN_EXPERIMENT_8_RESULTS,\n 9: BRENEMAN_EXPERIMENT_9_RESULTS,\n 10: BRENEMAN_EXPERIMENT_10_RESULTS,\n 11: BRENEMAN_EXPERIMENT_11_RESULTS,\n 12: BRENEMAN_EXPERIMENT_12_RESULTS\n})\nBRENEMAN_EXPERIMENTS.__doc__ = \"\"\"\n*Breneman (1987)* experiments.\n\nReferences\n----------\n:cite:`Breneman1987b`\n\nBRENEMAN_EXPERIMENTS : dict\n\"\"\"\n",
"# -*- coding: utf-8 -*-\n\"\"\"\nITU-R BT.1886\n=============\n\nDefines *Recommendation ITU-R BT.1886* electro-optical transfer function\n(EOTF / EOCF) and its inverse:\n\n- :func:`colour.models.eotf_inverse_BT1886`\n- :func:`colour.models.eotf_BT1886`\n\nSee Also\n--------\n`RGB Colourspaces Jupyter Notebook\n<http://nbviewer.jupyter.org/github/colour-science/colour-notebooks/\\\nblob/master/notebooks/models/rgb.ipynb>`_\n\nReferences\n----------\n- :cite:`InternationalTelecommunicationUnion2011h` : International\n Telecommunication Union. (2011). Recommendation ITU-R BT.1886 - Reference\n electro-optical transfer function for flat panel displays used in HDTV\n studio production BT Series Broadcasting service. Retrieved from\n https://www.itu.int/dms_pubrec/itu-r/rec/bt/\\\nR-REC-BT.1886-0-201103-I!!PDF-E.pdf\n\"\"\"\n\nfrom __future__ import division, unicode_literals\n\nimport numpy as np\n\nfrom colour.utilities import from_range_1, to_domain_1\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2019 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = '[email protected]'\n__status__ = 'Production'\n\n__all__ = ['eotf_inverse_BT1886', 'eotf_BT1886']\n\n\ndef eotf_inverse_BT1886(L, L_B=0, L_W=1):\n \"\"\"\n Defines *Recommendation ITU-R BT.1886* inverse electro-optical transfer\n function (EOTF / EOCF).\n\n Parameters\n ----------\n L : numeric or array_like\n Screen luminance in :math:`cd/m^2`.\n L_B : numeric, optional\n Screen luminance for black.\n L_W : numeric, optional\n Screen luminance for white.\n\n Returns\n -------\n numeric or ndarray\n Input video signal level (normalised, black at :math:`V = 0`, to white\n at :math:`V = 1`.\n\n Notes\n -----\n\n +------------+-----------------------+---------------+\n | **Domain** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``L`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n +------------+-----------------------+---------------+\n | **Range** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``V`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n References\n ----------\n :cite:`InternationalTelecommunicationUnion2011h`\n\n Examples\n --------\n >>> eotf_inverse_BT1886(0.11699185725296059) # doctest: +ELLIPSIS\n 0.4090077...\n \"\"\"\n\n L = to_domain_1(L)\n\n gamma = 2.40\n gamma_d = 1 / gamma\n\n n = L_W ** gamma_d - L_B ** gamma_d\n a = n ** gamma\n b = L_B ** gamma_d / n\n\n V = (L / a) ** gamma_d - b\n\n return from_range_1(V)\n\n\ndef eotf_BT1886(V, L_B=0, L_W=1):\n \"\"\"\n Defines *Recommendation ITU-R BT.1886* electro-optical transfer function\n (EOTF / EOCF).\n\n Parameters\n ----------\n V : numeric or array_like\n Input video signal level (normalised, black at :math:`V = 0`, to white\n at :math:`V = 1`. For content mastered per\n *Recommendation ITU-R BT.709*, 10-bit digital code values :math:`D` map\n into values of :math:`V` per the following equation:\n :math:`V = (D-64)/876`\n L_B : numeric, optional\n Screen luminance for black.\n L_W : numeric, optional\n Screen luminance for white.\n\n Returns\n -------\n numeric or ndarray\n Screen luminance in :math:`cd/m^2`.\n\n Notes\n -----\n\n +------------+-----------------------+---------------+\n | **Domain** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``V`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n +------------+-----------------------+---------------+\n | **Range** | **Scale - Reference** | **Scale - 1** |\n +============+=======================+===============+\n | ``L`` | [0, 1] | [0, 1] |\n +------------+-----------------------+---------------+\n\n References\n ----------\n :cite:`InternationalTelecommunicationUnion2011h`\n\n Examples\n --------\n >>> eotf_BT1886(0.409007728864150) # doctest: +ELLIPSIS\n 0.1169918...\n \"\"\"\n\n V = to_domain_1(V)\n\n gamma = 2.40\n gamma_d = 1 / gamma\n\n n = L_W ** gamma_d - L_B ** gamma_d\n a = n ** gamma\n b = L_B ** gamma_d / n\n L = a * np.maximum(V + b, 0) ** gamma\n\n return from_range_1(L)\n",
"# -*- coding: utf-8 -*-\n\"\"\"\nDefines unit tests for :mod:`colour.volume.mesh` module.\n\"\"\"\n\nfrom __future__ import division, unicode_literals\n\nimport numpy as np\nimport unittest\nfrom itertools import permutations\n\nfrom colour.volume import is_within_mesh_volume\nfrom colour.utilities import ignore_numpy_errors\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2019 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = '[email protected]'\n__status__ = 'Production'\n\n__all__ = ['TestIsWithinMeshVolume']\n\n\nclass TestIsWithinMeshVolume(unittest.TestCase):\n \"\"\"\n Defines :func:`colour.volume.mesh.is_within_mesh_volume` definition unit\n tests methods.\n \"\"\"\n\n def setUp(self):\n \"\"\"\n Initialises common tests attributes.\n \"\"\"\n\n self._mesh = np.array([\n [-1.0, -1.0, 1.0],\n [1.0, -1.0, 1.0],\n [1.0, -1.0, -1.0],\n [-1.0, -1.0, -1.0],\n [0.0, 1.0, 0.0],\n ])\n\n def test_is_within_mesh_volume(self):\n \"\"\"\n Tests :func:`colour.volume.mesh.is_within_mesh_volume` definition.\n \"\"\"\n\n self.assertTrue(\n is_within_mesh_volume(\n np.array([0.0005, 0.0031, 0.0010]), self._mesh))\n\n self.assertFalse(\n is_within_mesh_volume(\n np.array([0.3205, 0.4131, 0.5100]), self._mesh))\n\n self.assertTrue(\n is_within_mesh_volume(\n np.array([0.0025, 0.0088, 0.0340]), self._mesh))\n\n self.assertFalse(\n is_within_mesh_volume(\n np.array([0.4325, 0.3788, 0.1034]), self._mesh))\n\n def test_n_dimensional_is_within_mesh_volume(self):\n \"\"\"\n Tests :func:`colour.volume.mesh.is_within_mesh_volume` definition\n n-dimensional arrays support.\n \"\"\"\n\n a = np.array([0.0005, 0.0031, 0.0010])\n b = is_within_mesh_volume(a, self._mesh)\n\n a = np.tile(a, (6, 1))\n b = np.tile(b, 6)\n np.testing.assert_almost_equal(is_within_mesh_volume(a, self._mesh), b)\n\n a = np.reshape(a, (2, 3, 3))\n b = np.reshape(b, (2, 3))\n np.testing.assert_almost_equal(is_within_mesh_volume(a, self._mesh), b)\n\n @ignore_numpy_errors\n def test_nan_is_within_mesh_volume(self):\n \"\"\"\n Tests :func:`colour.volume.mesh.is_within_mesh_volume` definition nan\n support.\n \"\"\"\n\n cases = [-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]\n cases = set(permutations(cases * 3, r=3))\n for case in cases:\n is_within_mesh_volume(case, self._mesh)\n\n\nif __name__ == '__main__':\n unittest.main()\n",
"# -*- coding: utf-8 -*-\n\"\"\"\nCommon Utilities\n================\n\nDefines common utilities objects that don't fall in any specific category.\n\nReferences\n----------\n- :cite:`Kienzle2011a` : Kienzle, P., Patel, N., & Krycka, J. (2011).\n refl1d.numpyerrors - Refl1D v0.6.19 documentation. Retrieved January 30,\n 2015, from http://www.reflectometry.org/danse/docs/refl1d/_modules/\\\nrefl1d/numpyerrors.html\n\"\"\"\n\nfrom __future__ import division, unicode_literals\n\nimport inspect\nimport multiprocessing\nimport multiprocessing.pool\nimport functools\nimport numpy as np\nimport re\nimport six\nimport warnings\nfrom contextlib import contextmanager\nfrom collections import OrderedDict\nfrom copy import copy\nfrom six import integer_types, string_types\n\nfrom colour.constants import INTEGER_THRESHOLD, DEFAULT_FLOAT_DTYPE\nfrom colour.utilities import Lookup\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2019 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = '[email protected]'\n__status__ = 'Production'\n\n__all__ = [\n 'handle_numpy_errors', 'ignore_numpy_errors', 'raise_numpy_errors',\n 'print_numpy_errors', 'warn_numpy_errors', 'ignore_python_warnings',\n 'batch', 'disable_multiprocessing', 'multiprocessing_pool',\n 'is_networkx_installed', 'is_openimageio_installed', 'is_pandas_installed',\n 'is_iterable', 'is_string', 'is_numeric', 'is_integer', 'is_sibling',\n 'filter_kwargs', 'filter_mapping', 'first_item', 'get_domain_range_scale',\n 'set_domain_range_scale', 'domain_range_scale', 'to_domain_1',\n 'to_domain_10', 'to_domain_100', 'to_domain_degrees', 'to_domain_int',\n 'from_range_1', 'from_range_10', 'from_range_100', 'from_range_degrees',\n 'from_range_int'\n]\n\n\ndef handle_numpy_errors(**kwargs):\n \"\"\"\n Decorator for handling *Numpy* errors.\n\n Other Parameters\n ----------------\n \\\\**kwargs : dict, optional\n Keywords arguments.\n\n Returns\n -------\n object\n\n References\n ----------\n :cite:`Kienzle2011a`\n\n Examples\n --------\n >>> import numpy\n >>> @handle_numpy_errors(all='ignore')\n ... def f():\n ... 1 / numpy.zeros(3)\n >>> f()\n \"\"\"\n\n context = np.errstate(**kwargs)\n\n def wrapper(function):\n \"\"\"\n Wrapper for given function.\n \"\"\"\n\n @functools.wraps(function)\n def wrapped(*args, **kwargs):\n \"\"\"\n Wrapped function.\n \"\"\"\n\n with context:\n return function(*args, **kwargs)\n\n return wrapped\n\n return wrapper\n\n\nignore_numpy_errors = handle_numpy_errors(all='ignore')\nraise_numpy_errors = handle_numpy_errors(all='raise')\nprint_numpy_errors = handle_numpy_errors(all='print')\nwarn_numpy_errors = handle_numpy_errors(all='warn')\n\n\ndef ignore_python_warnings(function):\n \"\"\"\n Decorator for ignoring *Python* warnings.\n\n Parameters\n ----------\n function : object\n Function to decorate.\n\n Returns\n -------\n object\n\n Examples\n --------\n >>> @ignore_python_warnings\n ... def f():\n ... warnings.warn('This is an ignored warning!')\n >>> f()\n \"\"\"\n\n @functools.wraps(function)\n def wrapped(*args, **kwargs):\n \"\"\"\n Wrapped function.\n \"\"\"\n\n with warnings.catch_warnings():\n warnings.simplefilter('ignore')\n\n return function(*args, **kwargs)\n\n return wrapped\n\n\ndef batch(iterable, k=3):\n \"\"\"\n Returns a batch generator from given iterable.\n\n Parameters\n ----------\n iterable : iterable\n Iterable to create batches from.\n k : integer\n Batches size.\n\n Returns\n -------\n bool\n Is *string_like* variable.\n\n Examples\n --------\n >>> batch(tuple(range(10))) # doctest: +ELLIPSIS\n <generator object batch at 0x...>\n \"\"\"\n\n for i in range(0, len(iterable), k):\n yield iterable[i:i + k]\n\n\n_MULTIPROCESSING_ENABLED = True\n\"\"\"\nWhether *Colour* multiprocessing is enabled.\n\n_MULTIPROCESSING_ENABLED : bool\n\"\"\"\n\n\nclass disable_multiprocessing(object):\n \"\"\"\n A context manager and decorator temporarily disabling *Colour*\n multiprocessing.\n \"\"\"\n\n def __enter__(self):\n \"\"\"\n Called upon entering the context manager and decorator.\n \"\"\"\n\n global _MULTIPROCESSING_ENABLED\n\n _MULTIPROCESSING_ENABLED = False\n\n return self\n\n def __exit__(self, *args):\n \"\"\"\n Called upon exiting the context manager and decorator.\n \"\"\"\n\n global _MULTIPROCESSING_ENABLED\n\n _MULTIPROCESSING_ENABLED = True\n\n def __call__(self, function):\n \"\"\"\n Calls the wrapped definition.\n \"\"\"\n\n @functools.wraps(function)\n def wrapper(*args, **kwargs):\n with self:\n return function(*args, **kwargs)\n\n return wrapper\n\n\ndef _initializer(kwargs):\n \"\"\"\n Initializer for the multiprocessing pool. It is mainly use to ensure that\n processes on *Windows* correctly inherit from the current domain-range\n scale.\n\n Parameters\n ----------\n kwargs : dict\n Initialisation arguments.\n \"\"\"\n\n global _DOMAIN_RANGE_SCALE\n\n # NOTE: No coverage information is available as this code is executed in\n # sub-processes.\n _DOMAIN_RANGE_SCALE = kwargs.get('scale', 'reference') # pragma: no cover\n\n\n@contextmanager\ndef multiprocessing_pool(*args, **kwargs):\n \"\"\"\n A context manager providing a multiprocessing pool.\n\n Other Parameters\n ----------------\n \\\\*args : list, optional\n Arguments.\n \\\\**kwargs : dict, optional\n Keywords arguments.\n\n Examples\n --------\n >>> from functools import partial\n >>> def _add(a, b):\n ... return a + b\n >>> with multiprocessing_pool() as pool:\n ... pool.map(partial(_add, b=2), range(10))\n ... # doctest: +SKIP\n [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n \"\"\"\n\n class _DummyPool(object):\n \"\"\"\n A dummy multiprocessing pool that does not perform multiprocessing.\n\n Other Parameters\n ----------------\n \\\\*args : list, optional\n Arguments.\n \\\\**kwargs : dict, optional\n Keywords arguments.\n \"\"\"\n\n def __init__(self, *args, **kwargs):\n pass\n\n def map(self, func, iterable, chunksize=None):\n \"\"\"\n Applies given function to each element of given iterable.\n \"\"\"\n\n return [func(a) for a in iterable]\n\n def terminate(self):\n \"\"\"\n Terminate the process.\n \"\"\"\n\n pass\n\n kwargs['initializer'] = _initializer\n kwargs['initargs'] = ({'scale': get_domain_range_scale()}, )\n\n if _MULTIPROCESSING_ENABLED:\n pool_factory = multiprocessing.Pool\n else:\n pool_factory = _DummyPool\n\n pool = pool_factory(*args, **kwargs)\n\n try:\n yield pool\n finally:\n pool.terminate()\n\n\ndef is_networkx_installed(raise_exception=False):\n \"\"\"\n Returns if *NetworkX* is installed and available.\n\n Parameters\n ----------\n raise_exception : bool\n Raise exception if *NetworkX* is unavailable.\n\n Returns\n -------\n bool\n Is *NetworkX* installed.\n\n Raises\n ------\n ImportError\n If *NetworkX* is not installed.\n \"\"\"\n\n try: # pragma: no cover\n import networkx # noqa\n\n return True\n except ImportError as error: # pragma: no cover\n if raise_exception:\n raise ImportError(('\"NetworkX\" related API features, e.g. '\n 'the automatic colour conversion graph, '\n 'are not available: \"{0}\".').format(error))\n return False\n\n\ndef is_openimageio_installed(raise_exception=False):\n \"\"\"\n Returns if *OpenImageIO* is installed and available.\n\n Parameters\n ----------\n raise_exception : bool\n Raise exception if *OpenImageIO* is unavailable.\n\n Returns\n -------\n bool\n Is *OpenImageIO* installed.\n\n Raises\n ------\n ImportError\n If *OpenImageIO* is not installed.\n \"\"\"\n\n try: # pragma: no cover\n import OpenImageIO # noqa\n\n return True\n except ImportError as error: # pragma: no cover\n if raise_exception:\n raise ImportError(('\"OpenImageIO\" related API features '\n 'are not available: \"{0}\".').format(error))\n return False\n\n\ndef is_pandas_installed(raise_exception=False):\n \"\"\"\n Returns if *Pandas* is installed and available.\n\n Parameters\n ----------\n raise_exception : bool\n Raise exception if *Pandas* is unavailable.\n\n Returns\n -------\n bool\n Is *Pandas* installed.\n\n Raises\n ------\n ImportError\n If *Pandas* is not installed.\n \"\"\"\n\n try: # pragma: no cover\n import pandas # noqa\n\n return True\n except ImportError as error: # pragma: no cover\n if raise_exception:\n raise ImportError(('\"Pandas\" related API features '\n 'are not available: \"{0}\".').format(error))\n return False\n\n\ndef is_iterable(a):\n \"\"\"\n Returns if given :math:`a` variable is iterable.\n\n Parameters\n ----------\n a : object\n Variable to check the iterability.\n\n Returns\n -------\n bool\n :math:`a` variable iterability.\n\n Examples\n --------\n >>> is_iterable([1, 2, 3])\n True\n >>> is_iterable(1)\n False\n \"\"\"\n\n return is_string(a) or (True if getattr(a, '__iter__', False) else False)\n\n\ndef is_string(a):\n \"\"\"\n Returns if given :math:`a` variable is a *string* like variable.\n\n Parameters\n ----------\n a : object\n Data to test.\n\n Returns\n -------\n bool\n Is :math:`a` variable a *string* like variable.\n\n Examples\n --------\n >>> is_string(\"I'm a string!\")\n True\n >>> is_string([\"I'm a string!\"])\n False\n \"\"\"\n\n return True if isinstance(a, string_types) else False\n\n\ndef is_numeric(a):\n \"\"\"\n Returns if given :math:`a` variable is a number.\n\n Parameters\n ----------\n a : object\n Variable to check.\n\n Returns\n -------\n bool\n Is :math:`a` variable a number.\n\n Examples\n --------\n >>> is_numeric(1)\n True\n >>> is_numeric((1,))\n False\n \"\"\"\n\n return isinstance(\n a,\n tuple(\n list(integer_types) +\n [float, complex, np.integer, np.floating, np.complex]))\n\n\ndef is_integer(a):\n \"\"\"\n Returns if given :math:`a` variable is an integer under given threshold.\n\n Parameters\n ----------\n a : object\n Variable to check.\n\n Returns\n -------\n bool\n Is :math:`a` variable an integer.\n\n Notes\n -----\n - The determination threshold is defined by the\n :attr:`colour.algebra.common.INTEGER_THRESHOLD` attribute.\n\n Examples\n --------\n >>> is_integer(1)\n True\n >>> is_integer(1.01)\n False\n \"\"\"\n\n return abs(a - round(a)) <= INTEGER_THRESHOLD\n\n\ndef is_sibling(element, mapping):\n \"\"\"\n Returns whether given element type is present in given mapping types.\n\n Parameters\n ----------\n element : object\n Element to check if its type is present in the mapping types.\n mapping : dict\n Mapping.\n\n Returns\n -------\n bool\n Whether given element type is present in given mapping types.\n \"\"\"\n\n return isinstance(\n element, tuple(set(type(element) for element in mapping.values())))\n\n\ndef filter_kwargs(function, **kwargs):\n \"\"\"\n Filters keyword arguments incompatible with the given function signature.\n\n Parameters\n ----------\n function : callable\n Callable to filter the incompatible keyword arguments.\n\n Other Parameters\n ----------------\n \\\\**kwargs : dict, optional\n Keywords arguments.\n\n Returns\n -------\n dict\n Filtered keyword arguments.\n\n Warnings\n --------\n Python 2.7 does not support inspecting the signature of *partial*\n functions, this could cause unexpected behaviour when using this\n definition.\n\n Examples\n --------\n >>> def fn_a(a):\n ... return a\n >>> def fn_b(a, b=0):\n ... return a, b\n >>> def fn_c(a, b=0, c=0):\n ... return a, b, c\n >>> fn_a(1, **filter_kwargs(fn_a, b=2, c=3))\n 1\n >>> fn_b(1, **filter_kwargs(fn_b, b=2, c=3))\n (1, 2)\n >>> fn_c(1, **filter_kwargs(fn_c, b=2, c=3))\n (1, 2, 3)\n \"\"\"\n\n kwargs = copy(kwargs)\n\n # TODO: Remove when dropping Python 2.7.\n if six.PY2: # pragma: no cover\n try:\n args, _varargs, _keywords, _defaults = inspect.getargspec(function)\n except (TypeError, ValueError):\n return {}\n else: # pragma: no cover\n try:\n args = list(inspect.signature(function).parameters.keys())\n except ValueError:\n return {}\n\n args = set(kwargs.keys()) - set(args)\n for key in args:\n kwargs.pop(key)\n\n return kwargs\n\n\ndef filter_mapping(mapping, filterers, anchors=True, flags=re.IGNORECASE):\n \"\"\"\n Filters given mapping with given filterers.\n\n Parameters\n ----------\n mapping : dict_like\n Mapping to filter.\n filterers : unicode or object or array_like\n Filterer pattern for given mapping elements or a list of filterers.\n anchors : bool, optional\n Whether to use Regex line anchors, i.e. *^* and *$* are added,\n surrounding the filterer pattern.\n flags : int, optional\n Regex flags.\n\n Returns\n -------\n OrderedDict\n Filtered mapping elements.\n\n Notes\n -----\n - To honour the filterers ordering, the return value is an\n :class:`OrderedDict` class instance.\n\n Examples\n --------\n >>> class Element(object):\n ... pass\n >>> mapping = {\n ... 'Element A': Element(),\n ... 'Element B': Element(),\n ... 'Element C': Element(),\n ... 'Not Element C': Element(),\n ... }\n >>> # Doctests skip for Python 2.x compatibility.\n >>> filter_mapping(mapping, '\\\\w+\\\\s+A') # doctest: +SKIP\n {u'Element A': <colour.utilities.common.Element object at 0x...>}\n >>> # Doctests skip for Python 2.x compatibility.\n >>> sorted(filter_mapping(mapping, 'Element.*')) # doctest: +SKIP\n [u'Element A', u'Element B', u'Element C']\n \"\"\"\n\n def filter_mapping_with_filter(mapping, filterer, anchors, flags):\n \"\"\"\n Filters given mapping with given filterer.\n\n Parameters\n ----------\n mapping : dict_like\n Mapping to filter.\n filterer : unicode or object\n Filterer pattern for given mapping elements.\n anchors : bool, optional\n Whether to use Regex line anchors, i.e. *^* and *$* are added,\n surrounding the filterer pattern.\n flags : int, optional\n Regex flags.\n\n Returns\n -------\n OrderedDict\n Filtered mapping elements.\n \"\"\"\n\n if anchors:\n filterer = '^{0}$'.format(filterer)\n filterer = filterer.replace('^^', '^').replace('$$', '$')\n\n elements = [\n mapping[element] for element in mapping\n if re.match(filterer, element, flags)\n ]\n\n lookup = Lookup(mapping)\n\n return OrderedDict((lookup.first_key_from_value(element), element)\n for element in elements)\n\n if is_string(filterers):\n filterers = [filterers]\n\n filtered_mapping = OrderedDict()\n\n for filterer in filterers:\n filtered_mapping.update(\n filter_mapping_with_filter(mapping, filterer, anchors, flags))\n\n return filtered_mapping\n\n\ndef first_item(a):\n \"\"\"\n Return the first item of an iterable.\n\n Parameters\n ----------\n a : object\n Iterable to get the first item from.\n\n Returns\n -------\n object\n\n Raises\n ------\n StopIteration\n If the iterable is empty.\n\n Examples\n --------\n >>> a = range(10)\n >>> first_item(a)\n 0\n \"\"\"\n\n return next(iter(a))\n\n\n_DOMAIN_RANGE_SCALE = 'reference'\n\"\"\"\nGlobal variable storing the current *Colour* domain-range scale.\n\n_DOMAIN_RANGE_SCALE : unicode\n\"\"\"\n\n\ndef get_domain_range_scale():\n \"\"\"\n Returns the current *Colour* domain-range scale. The following scales are\n available:\n\n - **'Reference'**, the default *Colour* domain-range scale which varies\n depending on the referenced algorithm, e.g. [0, 1], [0, 10], [0, 100],\n [0, 255], etc...\n - **'1'**, a domain-range scale normalised to [0, 1], it is important to\n acknowledge that this is a soft normalisation and it is possible to\n use negative out of gamut values or high dynamic range data exceeding\n 1.\n\n Returns\n -------\n unicode\n *Colour* domain-range scale.\n \"\"\"\n\n return _DOMAIN_RANGE_SCALE\n\n\ndef set_domain_range_scale(scale='Reference'):\n \"\"\"\n Sets the current *Colour* domain-range scale. The following scales are\n available:\n\n - **'Reference'**, the default *Colour* domain-range scale which varies\n depending on the referenced algorithm, e.g. [0, 1], [0, 10], [0, 100],\n [0, 255], etc...\n - **'1'**, a domain-range scale normalised to [0, 1], it is important to\n acknowledge that this is a soft normalisation and it is possible to\n use negative out of gamut values or high dynamic range data exceeding\n 1.\n\n Parameters\n ----------\n scale : unicode or int\n **{'Reference', '1'}**,\n *Colour* domain-range scale to set.\n \"\"\"\n\n global _DOMAIN_RANGE_SCALE\n\n scale = str(scale).lower()\n valid = ('1', '100', 'reference', 'ignore')\n assert scale in valid, 'Scale must be one of \"{0}\".'.format(valid)\n\n _DOMAIN_RANGE_SCALE = scale\n\n\nclass domain_range_scale(object):\n \"\"\"\n A context manager and decorator temporarily setting *Colour* domain-range\n scale. The following scales are available:\n\n - **'Reference'**, the default *Colour* domain-range scale which varies\n depending on the referenced algorithm, e.g. [0, 1], [0, 10], [0, 100],\n [0, 255], etc...\n - **'1'**, a domain-range scale normalised to [0, 1], it is important to\n acknowledge that this is a soft normalisation and it is possible to\n use negative out of gamut values or high dynamic range data exceeding\n 1.\n\n Parameters\n ----------\n scale : unicode\n **{'Reference', '1'}**,\n *Colour* domain-range scale to set.\n \"\"\"\n\n def __init__(self, scale):\n self._scale = scale\n self._previous_scale = get_domain_range_scale()\n\n def __enter__(self):\n \"\"\"\n Called upon entering the context manager and decorator.\n \"\"\"\n\n set_domain_range_scale(self._scale)\n\n return self\n\n def __exit__(self, *args):\n \"\"\"\n Called upon exiting the context manager and decorator.\n \"\"\"\n\n set_domain_range_scale(self._previous_scale)\n\n def __call__(self, function):\n \"\"\"\n Calls the wrapped definition.\n \"\"\"\n\n @functools.wraps(function)\n def wrapper(*args, **kwargs):\n with self:\n return function(*args, **kwargs)\n\n return wrapper\n\n\ndef to_domain_1(a, scale_factor=100, dtype=DEFAULT_FLOAT_DTYPE):\n \"\"\"\n Scales given array :math:`a` to domain **'1'**. The behaviour is as\n follows:\n\n - If *Colour* domain-range scale is **'Reference'** or **'1'**, the\n definition is almost entirely by-passed and will just conveniently\n convert array :math:`a` to :class:`np.ndarray`.\n - If *Colour* domain-range scale is **'100'** (currently unsupported\n private value only used for unit tests), array :math:`a` is divided by\n ``scale_factor``, typically 100.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale to domain **'1'**.\n scale_factor : numeric or array_like, optional\n Scale factor, usually *numeric* but can be an *array_like* if some\n axis need different scaling to be brought to domain **'1'**.\n dtype : object, optional\n Data type used for the conversion to :class:`np.ndarray`.\n\n Returns\n -------\n ndarray\n :math:`a` scaled to domain **'1'**.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... to_domain_1(1)\n array(1.0)\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... to_domain_1(1)\n array(1.0)\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... to_domain_1(1)\n array(0.01)\n \"\"\"\n\n a = np.asarray(a, dtype).copy()\n\n if _DOMAIN_RANGE_SCALE == '100':\n a /= scale_factor\n\n return a\n\n\ndef to_domain_10(a, scale_factor=10, dtype=DEFAULT_FLOAT_DTYPE):\n \"\"\"\n Scales given array :math:`a` to domain **'10'**, used by\n *Munsell Renotation System*. The behaviour is as follows:\n\n - If *Colour* domain-range scale is **'Reference'**, the\n definition is almost entirely by-passed and will just conveniently\n convert array :math:`a` to :class:`np.ndarray`.\n - If *Colour* domain-range scale is **'1'**, array :math:`a` is\n multiplied by ``scale_factor``, typically 10.\n - If *Colour* domain-range scale is **'100'** (currently unsupported\n private value only used for unit tests), array :math:`a` is\n divided by ``scale_factor``, typically 10.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale to domain **'10'**.\n scale_factor : numeric or array_like, optional\n Scale factor, usually *numeric* but can be an *array_like* if some\n axis need different scaling to be brought to domain **'10'**.\n dtype : object, optional\n Data type used for the conversion to :class:`np.ndarray`.\n\n Returns\n -------\n ndarray\n :math:`a` scaled to domain **'10'**.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... to_domain_10(1)\n array(1.0)\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... to_domain_10(1)\n array(10.0)\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... to_domain_10(1)\n array(0.1)\n \"\"\"\n\n a = np.asarray(a, dtype).copy()\n\n if _DOMAIN_RANGE_SCALE == '1':\n a *= scale_factor\n\n if _DOMAIN_RANGE_SCALE == '100':\n a /= scale_factor\n\n return a\n\n\ndef to_domain_100(a, scale_factor=100, dtype=DEFAULT_FLOAT_DTYPE):\n \"\"\"\n Scales given array :math:`a` to domain **'100'**. The behaviour is as\n follows:\n\n - If *Colour* domain-range scale is **'Reference'** or **'100'**\n (currently unsupported private value only used for unit tests), the\n definition is almost entirely by-passed and will just conveniently\n convert array :math:`a` to :class:`np.ndarray`.\n - If *Colour* domain-range scale is **'1'**, array :math:`a` is\n multiplied by ``scale_factor``, typically 100.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale to domain **'100'**.\n scale_factor : numeric or array_like, optional\n Scale factor, usually *numeric* but can be an *array_like* if some\n axis need different scaling to be brought to domain **'100'**.\n dtype : object, optional\n Data type used for the conversion to :class:`np.ndarray`.\n\n Returns\n -------\n ndarray\n :math:`a` scaled to domain **'100'**.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... to_domain_100(1)\n array(1.0)\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... to_domain_100(1)\n array(100.0)\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... to_domain_100(1)\n array(1.0)\n \"\"\"\n\n a = np.asarray(a, dtype).copy()\n\n if _DOMAIN_RANGE_SCALE == '1':\n a *= scale_factor\n\n return a\n\n\ndef to_domain_degrees(a, scale_factor=360, dtype=DEFAULT_FLOAT_DTYPE):\n \"\"\"\n Scales given array :math:`a` to degrees domain. The behaviour is as\n follows:\n\n - If *Colour* domain-range scale is **'Reference'**, the\n definition is almost entirely by-passed and will just conveniently\n convert array :math:`a` to :class:`np.ndarray`.\n - If *Colour* domain-range scale is **'1'**, array :math:`a` is\n multiplied by ``scale_factor``, typically 360.\n - If *Colour* domain-range scale is **'100'** (currently unsupported\n private value only used for unit tests), array :math:`a` is\n multiplied by ``scale_factor`` / 100, typically 360 / 100.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale to degrees domain.\n scale_factor : numeric or array_like, optional\n Scale factor, usually *numeric* but can be an *array_like* if some\n axis need different scaling to be brought to degrees domain.\n dtype : object, optional\n Data type used for the conversion to :class:`np.ndarray`.\n\n Returns\n -------\n ndarray\n :math:`a` scaled to degrees domain.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... to_domain_degrees(1)\n array(1.0)\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... to_domain_degrees(1)\n array(360.0)\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... to_domain_degrees(1)\n array(3.6)\n \"\"\"\n\n a = np.asarray(a, dtype).copy()\n\n if _DOMAIN_RANGE_SCALE == '1':\n a *= scale_factor\n\n if _DOMAIN_RANGE_SCALE == '100':\n a *= scale_factor / 100\n\n return a\n\n\ndef to_domain_int(a, bit_depth=8, dtype=DEFAULT_FLOAT_DTYPE):\n \"\"\"\n Scales given array :math:`a` to int domain. The behaviour is as follows:\n\n - If *Colour* domain-range scale is **'Reference'**, the\n definition is almost entirely by-passed and will just conveniently\n convert array :math:`a` to :class:`np.ndarray`.\n - If *Colour* domain-range scale is **'1'**, array :math:`a` is\n multiplied by :math:`2^{bit\\\\_depth} - 1`.\n - If *Colour* domain-range scale is **'100'** (currently unsupported\n private value only used for unit tests), array :math:`a` is\n multiplied by :math:`2^{bit\\\\_depth} - 1`.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale to int domain.\n bit_depth : numeric or array_like, optional\n Bit depth, usually *int* but can be an *array_like* if some axis need\n different scaling to be brought to int domain.\n dtype : object, optional\n Data type used for the conversion to :class:`np.ndarray`.\n\n Returns\n -------\n ndarray\n :math:`a` scaled to int domain.\n\n Notes\n -----\n - To avoid precision issues and rounding, the scaling is performed on\n floating-point numbers.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... to_domain_int(1)\n array(1.0)\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... to_domain_int(1)\n array(255.0)\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... to_domain_int(1)\n array(2.55)\n \"\"\"\n\n a = np.asarray(a, dtype).copy()\n\n maximum_code_value = 2 ** bit_depth - 1\n if _DOMAIN_RANGE_SCALE == '1':\n a *= maximum_code_value\n\n if _DOMAIN_RANGE_SCALE == '100':\n a *= maximum_code_value / 100\n\n return a\n\n\ndef from_range_1(a, scale_factor=100):\n \"\"\"\n Scales given array :math:`a` from range **'1'**. The behaviour is as\n follows:\n\n - If *Colour* domain-range scale is **'Reference'** or **'1'**, the\n definition is entirely by-passed.\n - If *Colour* domain-range scale is **'100'** (currently unsupported\n private value only used for unit tests), array :math:`a` is multiplied\n by ``scale_factor``, typically 100.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale from range **'1'**.\n scale_factor : numeric or array_like, optional\n Scale factor, usually *numeric* but can be an *array_like* if some\n axis need different scaling to be brought from range **'1'**.\n\n Returns\n -------\n ndarray\n :math:`a` scaled from range **'1'**.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... from_range_1(1)\n 1\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... from_range_1(1)\n 1\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... from_range_1(1)\n 100\n \"\"\"\n\n if _DOMAIN_RANGE_SCALE == '100':\n a *= scale_factor\n\n return a\n\n\ndef from_range_10(a, scale_factor=10):\n \"\"\"\n Scales given array :math:`a` from range **'10'**, used by\n *Munsell Renotation System*. The behaviour is as follows:\n\n - If *Colour* domain-range scale is **'Reference'**, the\n definition is entirely by-passed.\n - If *Colour* domain-range scale is **'1'**, array :math:`a` is\n divided by ``scale_factor``, typically 10.\n - If *Colour* domain-range scale is **'100'** (currently unsupported\n private value only used for unit tests), array :math:`a` is\n multiplied by ``scale_factor``, typically 10.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale from range **'10'**.\n scale_factor : numeric or array_like, optional\n Scale factor, usually *numeric* but can be an *array_like* if some\n axis need different scaling to be brought from range **'10'**.\n\n Returns\n -------\n ndarray\n :math:`a` scaled from range **'10'**.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... from_range_10(1)\n 1\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... from_range_10(1)\n 0.1\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... from_range_10(1)\n 10\n \"\"\"\n\n if _DOMAIN_RANGE_SCALE == '1':\n a /= scale_factor\n\n if _DOMAIN_RANGE_SCALE == '100':\n a *= scale_factor\n\n return a\n\n\ndef from_range_100(a, scale_factor=100):\n \"\"\"\n Scales given array :math:`a` from range **'100'**. The behaviour is as\n follows:\n\n - If *Colour* domain-range scale is **'Reference'** or **'100'**\n (currently unsupported private value only used for unit tests), the\n definition is entirely by-passed.\n - If *Colour* domain-range scale is **'1'**, array :math:`a` is\n divided by ``scale_factor``, typically 100.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale from range **'100'**.\n scale_factor : numeric or array_like, optional\n Scale factor, usually *numeric* but can be an *array_like* if some\n axis need different scaling to be brought from range **'100'**.\n\n Returns\n -------\n ndarray\n :math:`a` scaled from range **'100'**.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... from_range_100(1)\n 1\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... from_range_100(1)\n 0.01\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... from_range_100(1)\n 1\n \"\"\"\n\n if _DOMAIN_RANGE_SCALE == '1':\n a /= scale_factor\n\n return a\n\n\ndef from_range_degrees(a, scale_factor=360):\n \"\"\"\n Scales given array :math:`a` from degrees range. The behaviour is as\n follows:\n\n - If *Colour* domain-range scale is **'Reference'**, the\n definition is entirely by-passed.\n - If *Colour* domain-range scale is **'1'**, array :math:`a` is\n divided by ``scale_factor``, typically 360.\n - If *Colour* domain-range scale is **'100'** (currently unsupported\n private value only used for unit tests), array :math:`a` is\n divided by ``scale_factor`` / 100, typically 360 / 100.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale from degrees range.\n scale_factor : numeric or array_like, optional\n Scale factor, usually *numeric* but can be an *array_like* if some\n axis need different scaling to be brought from degrees range.\n\n Returns\n -------\n ndarray\n :math:`a` scaled from degrees range.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... from_range_degrees(1)\n 1\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... from_range_degrees(1) # doctest: +ELLIPSIS\n 0.0027777...\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... from_range_degrees(1) # doctest: +ELLIPSIS\n 0.2777777...\n \"\"\"\n\n if _DOMAIN_RANGE_SCALE == '1':\n a /= scale_factor\n\n if _DOMAIN_RANGE_SCALE == '100':\n a /= scale_factor / 100\n\n return a\n\n\ndef from_range_int(a, bit_depth=8, dtype=DEFAULT_FLOAT_DTYPE):\n \"\"\"\n Scales given array :math:`a` from int range. The behaviour is as follows:\n\n - If *Colour* domain-range scale is **'Reference'**, the\n definition is entirely by-passed.\n - If *Colour* domain-range scale is **'1'**, array :math:`a` is converted\n to :class:`np.ndarray` and divided by :math:`2^{bit\\\\_depth} - 1`.\n - If *Colour* domain-range scale is **'100'** (currently unsupported\n private value only used for unit tests), array :math:`a` is converted\n to :class:`np.ndarray` and divided by :math:`2^{bit\\\\_depth} - 1`.\n\n Parameters\n ----------\n a : array_like\n :math:`a` to scale from int range.\n bit_depth : numeric or array_like, optional\n Bit depth, usually *int* but can be an *array_like* if some axis need\n different scaling to be brought from int range.\n dtype : object, optional\n Data type used for the conversion to :class:`np.ndarray`.\n\n Returns\n -------\n ndarray\n :math:`a` scaled from int range.\n\n Notes\n -----\n - To avoid precision issues and rounding, the scaling is performed on\n floating-point numbers.\n\n Examples\n --------\n With *Colour* domain-range scale set to **'Reference'**:\n\n >>> with domain_range_scale('Reference'):\n ... from_range_int(1)\n 1\n\n With *Colour* domain-range scale set to **'1'**:\n\n >>> with domain_range_scale('1'):\n ... from_range_int(1) # doctest: +ELLIPSIS\n array(0.0039215...)\n\n With *Colour* domain-range scale set to **'100'** (unsupported):\n\n >>> with domain_range_scale('100'):\n ... from_range_int(1) # doctest: +ELLIPSIS\n array(0.3921568...)\n \"\"\"\n\n maximum_code_value = 2 ** bit_depth - 1\n if _DOMAIN_RANGE_SCALE == '1':\n a = np.asarray(a, dtype)\n a /= maximum_code_value\n\n if _DOMAIN_RANGE_SCALE == '100':\n a = np.asarray(a, dtype)\n a /= maximum_code_value / 100\n\n return a\n",
"# -*- coding: utf-8 -*-\n\"\"\"\n:math:`LLAB(l:c)` Colour Appearance Model\n=========================================\n\nDefines *:math:`LLAB(l:c)`* colour appearance model objects:\n\n- :class:`colour.appearance.LLAB_InductionFactors`\n- :attr:`colour.LLAB_VIEWING_CONDITIONS`\n- :class:`colour.LLAB_Specification`\n- :func:`colour.XYZ_to_LLAB`\n\nSee Also\n--------\n`LLAB(l:c) Colour Appearance Model Jupyter Notebook\n<http://nbviewer.jupyter.org/github/colour-science/colour-notebooks/\\\nblob/master/notebooks/appearance/llab.ipynb>`_\n\nReferences\n----------\n- :cite:`Fairchild2013x` : Fairchild, M. D. (2013). LLAB Model. In Color\n Appearance Models (3rd ed., pp. 6025-6178). Wiley. ISBN:B00DAYO8E2\n- :cite:`Luo1996b` : Luo, M. R., Lo, M.-C., & Kuo, W.-G. (1996). The LLAB\n (l:c) colour model. Color Research & Application, 21(6), 412-429.\n doi:10.1002/(SICI)1520-6378(199612)21:6<412::AID-COL4>3.0.CO;2-Z\n- :cite:`Luo1996c` : Luo, M. R., & Morovic, J. (1996). Two Unsolved Issues in\n Colour Management - Colour Appearance and Gamut Mapping. In Conference:\n 5th International Conference on High Technology: Imaging Science and\n Technology - Evolution & Promise (pp. 136-147). Retrieved from\n http://www.researchgate.net/publication/\\236348295_Two_Unsolved_Issues_in\\\n_Colour_Management__Colour_Appearance_and_Gamut_Mapping\n\"\"\"\n\nfrom __future__ import division, unicode_literals\n\nimport numpy as np\nfrom collections import namedtuple\n\nfrom colour.algebra import polar_to_cartesian, spow\nfrom colour.utilities import (CaseInsensitiveMapping, as_float_array,\n dot_vector, from_range_degrees, to_domain_100,\n tsplit, tstack)\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2019 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = '[email protected]'\n__status__ = 'Production'\n\n__all__ = [\n 'LLAB_InductionFactors', 'LLAB_VIEWING_CONDITIONS',\n 'LLAB_XYZ_TO_RGB_MATRIX', 'LLAB_RGB_TO_XYZ_MATRIX',\n 'LLAB_ReferenceSpecification', 'LLAB_Specification', 'XYZ_to_LLAB',\n 'XYZ_to_RGB_LLAB', 'chromatic_adaptation', 'f',\n 'opponent_colour_dimensions', 'hue_angle', 'chroma_correlate',\n 'colourfulness_correlate', 'saturation_correlate', 'final_opponent_signals'\n]\n\n\nclass LLAB_InductionFactors(\n namedtuple('LLAB_InductionFactors', ('D', 'F_S', 'F_L', 'F_C'))):\n \"\"\"\n *:math:`LLAB(l:c)`* colour appearance model induction factors.\n\n Parameters\n ----------\n D : numeric or array_like\n *Discounting-the-Illuminant* factor :math:`D`.\n F_S : numeric or array_like\n Surround induction factor :math:`F_S`.\n F_L : numeric or array_like\n *Lightness* induction factor :math:`F_L`.\n F_C : numeric or array_like\n *Chroma* induction factor :math:`F_C`.\n\n References\n ----------\n :cite:`Fairchild2013x`, :cite:`Luo1996b`, :cite:`Luo1996c`\n \"\"\"\n\n\nLLAB_VIEWING_CONDITIONS = CaseInsensitiveMapping({\n 'Reference Samples & Images, Average Surround, Subtending > 4': (\n LLAB_InductionFactors(1, 3, 0, 1)),\n 'Reference Samples & Images, Average Surround, Subtending < 4': (\n LLAB_InductionFactors(1, 3, 1, 1)),\n 'Television & VDU Displays, Dim Surround': (LLAB_InductionFactors(\n 0.7, 3.5, 1, 1)),\n 'Cut Sheet Transparency, Dim Surround': (LLAB_InductionFactors(\n 1, 5, 1, 1.1)),\n '35mm Projection Transparency, Dark Surround': (LLAB_InductionFactors(\n 0.7, 4, 1, 1))\n})\nLLAB_VIEWING_CONDITIONS.__doc__ = \"\"\"\nReference :math:`LLAB(l:c)` colour appearance model viewing conditions.\n\nReferences\n----------\n:cite:`Fairchild2013x`, :cite:`Luo1996b`, :cite:`Luo1996c`\n\nLLAB_VIEWING_CONDITIONS : CaseInsensitiveMapping\n **{'Reference Samples & Images, Average Surround, Subtending > 4',\n 'Reference Samples & Images, Average Surround, Subtending < 4',\n 'Television & VDU Displays, Dim Surround',\n 'Cut Sheet Transparency, Dim Surround':,\n '35mm Projection Transparency, Dark Surround'}**\n\nAliases:\n\n- 'ref_average_4_plus':\n 'Reference Samples & Images, Average Surround, Subtending > 4'\n- 'ref_average_4_minus':\n 'Reference Samples & Images, Average Surround, Subtending < 4'\n- 'tv_dim': 'Television & VDU Displays, Dim Surround'\n- 'sheet_dim': 'Cut Sheet Transparency, Dim Surround'\n- 'projected_dark': '35mm Projection Transparency, Dark Surround'\n\"\"\"\nLLAB_VIEWING_CONDITIONS['ref_average_4_plus'] = ( # yapf: disable\n LLAB_VIEWING_CONDITIONS['Reference Samples & Images, '\n 'Average Surround, Subtending > 4'])\nLLAB_VIEWING_CONDITIONS['ref_average_4_minus'] = ( # yapf: disable\n LLAB_VIEWING_CONDITIONS['Reference Samples & Images, '\n 'Average Surround, Subtending < 4'])\nLLAB_VIEWING_CONDITIONS['tv_dim'] = (\n LLAB_VIEWING_CONDITIONS['Television & VDU Displays, Dim Surround'])\nLLAB_VIEWING_CONDITIONS['sheet_dim'] = (\n LLAB_VIEWING_CONDITIONS['Cut Sheet Transparency, Dim Surround'])\nLLAB_VIEWING_CONDITIONS['projected_dark'] = (\n LLAB_VIEWING_CONDITIONS['35mm Projection Transparency, Dark Surround'])\n\nLLAB_XYZ_TO_RGB_MATRIX = np.array([\n [0.8951, 0.2664, -0.1614],\n [-0.7502, 1.7135, 0.0367],\n [0.0389, -0.0685, 1.0296],\n])\n\"\"\"\nLLAB(l:c) colour appearance model *CIE XYZ* tristimulus values to normalised\ncone responses matrix.\n\nLLAB_XYZ_TO_RGB_MATRIX : array_like, (3, 3)\n\"\"\"\n\nLLAB_RGB_TO_XYZ_MATRIX = np.linalg.inv(LLAB_XYZ_TO_RGB_MATRIX)\n\"\"\"\nLLAB(l:c) colour appearance model normalised cone responses to *CIE XYZ*\ntristimulus values matrix.\n\nLLAB_RGB_TO_XYZ_MATRIX : array_like, (3, 3)\n\"\"\"\n\n\nclass LLAB_ReferenceSpecification(\n namedtuple('LLAB_ReferenceSpecification',\n ('L_L', 'Ch_L', 'h_L', 's_L', 'C_L', 'HC', 'A_L', 'B_L'))):\n \"\"\"\n Defines the *:math:`LLAB(l:c)`* colour appearance model reference\n specification.\n\n This specification has field names consistent with *Fairchild (2013)*\n reference.\n\n Parameters\n ----------\n L_L : numeric or array_like\n Correlate of *Lightness* :math:`L_L`.\n Ch_L : numeric or array_like\n Correlate of *chroma* :math:`Ch_L`.\n h_L : numeric or array_like\n *Hue* angle :math:`h_L` in degrees.\n s_L : numeric or array_like\n Correlate of *saturation* :math:`s_L`.\n C_L : numeric or array_like\n Correlate of *colourfulness* :math:`C_L`.\n HC : numeric or array_like\n *Hue* :math:`h` composition :math:`H^C`.\n A_L : numeric or array_like\n Opponent signal :math:`A_L`.\n B_L : numeric or array_like\n Opponent signal :math:`B_L`.\n\n References\n ----------\n :cite:`Fairchild2013x`, :cite:`Luo1996b`, :cite:`Luo1996c`\n \"\"\"\n\n\nclass LLAB_Specification(\n namedtuple('LLAB_Specification',\n ('J', 'C', 'h', 's', 'M', 'HC', 'a', 'b'))):\n \"\"\"\n Defines the *:math:`LLAB(l:c)`* colour appearance model specification.\n\n This specification has field names consistent with the remaining colour\n appearance models in :mod:`colour.appearance` but diverge from\n *Fairchild (2013)* reference.\n\n Parameters\n ----------\n J : numeric or array_like\n Correlate of *Lightness* :math:`L_L`.\n C : numeric or array_like\n Correlate of *chroma* :math:`Ch_L`.\n h : numeric or array_like\n *Hue* angle :math:`h_L` in degrees.\n s : numeric or array_like\n Correlate of *saturation* :math:`s_L`.\n M : numeric or array_like\n Correlate of *colourfulness* :math:`C_L`.\n HC : numeric or array_like\n *Hue* :math:`h` composition :math:`H^C`.\n a : numeric or array_like\n Opponent signal :math:`A_L`.\n b : numeric or array_like\n Opponent signal :math:`B_L`.\n\n Notes\n -----\n - This specification is the one used in the current model implementation.\n\n References\n ----------\n :cite:`Fairchild2013x`, :cite:`Luo1996b`, :cite:`Luo1996c`\n \"\"\"\n\n\ndef XYZ_to_LLAB(\n XYZ,\n XYZ_0,\n Y_b,\n L,\n surround=LLAB_VIEWING_CONDITIONS[\n 'Reference Samples & Images, Average Surround, Subtending < 4']):\n \"\"\"\n Computes the *:math:`LLAB(l:c)`* colour appearance model correlates.\n\n Parameters\n ----------\n XYZ : array_like\n *CIE XYZ* tristimulus values of test sample / stimulus.\n XYZ_0 : array_like\n *CIE XYZ* tristimulus values of reference white.\n Y_b : numeric or array_like\n Luminance factor of the background in :math:`cd/m^2`.\n L : numeric or array_like\n Absolute luminance :math:`L` of reference white in :math:`cd/m^2`.\n surround : LLAB_InductionFactors, optional\n Surround viewing conditions induction factors.\n\n Returns\n -------\n LLAB_Specification\n *:math:`LLAB(l:c)`* colour appearance model specification.\n\n Notes\n -----\n\n +--------------------------+-----------------------+---------------+\n | **Domain** | **Scale - Reference** | **Scale - 1** |\n +==========================+=======================+===============+\n | ``XYZ`` | [0, 100] | [0, 1] |\n +--------------------------+-----------------------+---------------+\n | ``XYZ_0`` | [0, 100] | [0, 1] |\n +--------------------------+-----------------------+---------------+\n\n +--------------------------+-----------------------+---------------+\n | **Range** | **Scale - Reference** | **Scale - 1** |\n +==========================+=======================+===============+\n | ``LLAB_Specification.h`` | [0, 360] | [0, 1] |\n +--------------------------+-----------------------+---------------+\n\n References\n ----------\n :cite:`Fairchild2013x`, :cite:`Luo1996b`, :cite:`Luo1996c`\n\n Examples\n --------\n >>> XYZ = np.array([19.01, 20.00, 21.78])\n >>> XYZ_0 = np.array([95.05, 100.00, 108.88])\n >>> Y_b = 20.0\n >>> L = 318.31\n >>> surround = LLAB_VIEWING_CONDITIONS['ref_average_4_minus']\n >>> XYZ_to_LLAB(XYZ, XYZ_0, Y_b, L, surround) # doctest: +ELLIPSIS\n LLAB_Specification(J=37.3668650..., C=0.0089496..., h=270..., \\\ns=0.0002395..., M=0.0190185..., HC=None, a=..., b=-0.0190185...)\n \"\"\"\n\n _X, Y, _Z = tsplit(to_domain_100(XYZ))\n RGB = XYZ_to_RGB_LLAB(to_domain_100(XYZ))\n RGB_0 = XYZ_to_RGB_LLAB(to_domain_100(XYZ_0))\n\n # Reference illuminant *CIE Standard Illuminant D Series* *D65*.\n XYZ_0r = np.array([95.05, 100.00, 108.88])\n RGB_0r = XYZ_to_RGB_LLAB(XYZ_0r)\n\n # Computing chromatic adaptation.\n XYZ_r = chromatic_adaptation(RGB, RGB_0, RGB_0r, Y, surround.D)\n\n # -------------------------------------------------------------------------\n # Computing the correlate of *Lightness* :math:`L_L`.\n # -------------------------------------------------------------------------\n # Computing opponent colour dimensions.\n L_L, a, b = tsplit(\n opponent_colour_dimensions(XYZ_r, Y_b, surround.F_S, surround.F_L))\n\n # Computing perceptual correlates.\n # -------------------------------------------------------------------------\n # Computing the correlate of *chroma* :math:`Ch_L`.\n # -------------------------------------------------------------------------\n Ch_L = chroma_correlate(a, b)\n\n # -------------------------------------------------------------------------\n # Computing the correlate of *colourfulness* :math:`C_L`.\n # -------------------------------------------------------------------------\n C_L = colourfulness_correlate(L, L_L, Ch_L, surround.F_C)\n\n # -------------------------------------------------------------------------\n # Computing the correlate of *saturation* :math:`s_L`.\n # -------------------------------------------------------------------------\n s_L = saturation_correlate(Ch_L, L_L)\n\n # -------------------------------------------------------------------------\n # Computing the *hue* angle :math:`h_L`.\n # -------------------------------------------------------------------------\n h_L = hue_angle(a, b)\n # TODO: Implement hue composition computation.\n\n # -------------------------------------------------------------------------\n # Computing final opponent signals.\n # -------------------------------------------------------------------------\n A_L, B_L = tsplit(final_opponent_signals(C_L, h_L))\n\n return LLAB_Specification(L_L, Ch_L, from_range_degrees(h_L), s_L, C_L,\n None, A_L, B_L)\n\n\ndef XYZ_to_RGB_LLAB(XYZ):\n \"\"\"\n Converts from *CIE XYZ* tristimulus values to normalised cone responses.\n\n Parameters\n ----------\n XYZ : array_like\n *CIE XYZ* tristimulus values.\n\n Returns\n -------\n ndarray\n Normalised cone responses.\n\n Examples\n --------\n >>> XYZ = np.array([19.01, 20.00, 21.78])\n >>> XYZ_to_RGB_LLAB(XYZ) # doctest: +ELLIPSIS\n array([ 0.9414279..., 1.0404012..., 1.0897088...])\n \"\"\"\n\n _X, Y, _Z = tsplit(XYZ)\n\n Y = tstack([Y, Y, Y])\n XYZ_n = XYZ / Y\n\n return dot_vector(LLAB_XYZ_TO_RGB_MATRIX, XYZ_n)\n\n\ndef chromatic_adaptation(RGB, RGB_0, RGB_0r, Y, D=1):\n \"\"\"\n Applies chromatic adaptation to given *RGB* normalised cone responses\n array.\n\n Parameters\n ----------\n RGB : array_like\n *RGB* normalised cone responses array of test sample / stimulus.\n RGB_0 : array_like\n *RGB* normalised cone responses array of reference white.\n RGB_0r : array_like\n *RGB* normalised cone responses array of reference illuminant\n *CIE Standard Illuminant D Series* *D65*.\n Y : numeric or array_like\n Tristimulus values :math:`Y` of the stimulus.\n D : numeric or array_like, optional\n *Discounting-the-Illuminant* factor normalised to domain [0, 1].\n\n Returns\n -------\n ndarray\n Adapted *CIE XYZ* tristimulus values.\n\n Examples\n --------\n >>> RGB = np.array([0.94142795, 1.04040120, 1.08970885])\n >>> RGB_0 = np.array([0.94146023, 1.04039386, 1.08950293])\n >>> RGB_0r = np.array([0.94146023, 1.04039386, 1.08950293])\n >>> Y = 20.0\n >>> chromatic_adaptation(RGB, RGB_0, RGB_0r, Y) # doctest: +ELLIPSIS\n array([ 19.01, 20. , 21.78])\n \"\"\"\n\n R, G, B = tsplit(RGB)\n R_0, G_0, B_0 = tsplit(RGB_0)\n R_0r, G_0r, B_0r = tsplit(RGB_0r)\n Y = as_float_array(Y)\n\n beta = spow(B_0 / B_0r, 0.0834)\n\n R_r = (D * (R_0r / R_0) + 1 - D) * R\n G_r = (D * (G_0r / G_0) + 1 - D) * G\n B_r = (D * (B_0r / spow(B_0, beta)) + 1 - D) * spow(B, beta)\n\n RGB_r = tstack([R_r, G_r, B_r])\n\n Y = tstack([Y, Y, Y])\n\n XYZ_r = dot_vector(LLAB_RGB_TO_XYZ_MATRIX, RGB_r * Y)\n\n return XYZ_r\n\n\ndef f(x, F_S):\n \"\"\"\n Defines the nonlinear response function of the *:math:`LLAB(l:c)`* colour\n appearance model used to model the nonlinear behaviour of various visual\n responses.\n\n Parameters\n ----------\n x : numeric or array_like or array_like\n Visual response variable :math:`x`.\n F_S : numeric or array_like\n Surround induction factor :math:`F_S`.\n\n Returns\n -------\n numeric or array_like\n Modeled visual response variable :math:`x`.\n\n Examples\n --------\n >>> x = np.array([0.23350512, 0.23351103, 0.23355179])\n >>> f(0.200009186234000, 3) # doctest: +ELLIPSIS\n array(0.5848125...)\n \"\"\"\n\n x = as_float_array(x)\n F_S = as_float_array(F_S)\n\n x_m = np.where(\n x > 0.008856,\n spow(x, 1 / F_S),\n ((spow(0.008856, 1 / F_S) - (16 / 116)) / 0.008856) * x + (16 / 116),\n )\n\n return x_m\n\n\ndef opponent_colour_dimensions(XYZ, Y_b, F_S, F_L):\n \"\"\"\n Returns opponent colour dimensions from given adapted *CIE XYZ* tristimulus\n values.\n\n The opponent colour dimensions are based on a modified *CIE L\\\\*a\\\\*b\\\\**\n colourspace formulae.\n\n Parameters\n ----------\n XYZ : array_like\n Adapted *CIE XYZ* tristimulus values.\n Y_b : numeric or array_like\n Luminance factor of the background in :math:`cd/m^2`.\n F_S : numeric or array_like\n Surround induction factor :math:`F_S`.\n F_L : numeric or array_like\n Lightness induction factor :math:`F_L`.\n\n Returns\n -------\n ndarray\n Opponent colour dimensions.\n\n Examples\n --------\n >>> XYZ = np.array([19.00999572, 20.00091862, 21.77993863])\n >>> Y_b = 20.0\n >>> F_S = 3.0\n >>> F_L = 1.0\n >>> opponent_colour_dimensions(XYZ, Y_b, F_S, F_L) # doctest: +ELLIPSIS\n array([ 3.7368047...e+01, -4.4986443...e-03, -5.2604647...e-03])\n \"\"\"\n\n X, Y, Z = tsplit(XYZ)\n Y_b = as_float_array(Y_b)\n F_S = as_float_array(F_S)\n F_L = as_float_array(F_L)\n\n # Account for background lightness contrast.\n z = 1 + F_L * spow(Y_b / 100, 0.5)\n\n # Computing modified *CIE L\\\\*a\\\\*b\\\\** colourspace array.\n L = 116 * spow(f(Y / 100, F_S), z) - 16\n a = 500 * (f(X / 95.05, F_S) - f(Y / 100, F_S))\n b = 200 * (f(Y / 100, F_S) - f(Z / 108.88, F_S))\n\n Lab = tstack([L, a, b])\n\n return Lab\n\n\ndef hue_angle(a, b):\n \"\"\"\n Returns the *hue* angle :math:`h_L` in degrees.\n\n Parameters\n ----------\n a : numeric or array_like\n Opponent colour dimension :math:`a`.\n b : numeric or array_like\n Opponent colour dimension :math:`b`.\n\n Returns\n -------\n numeric or ndarray\n *Hue* angle :math:`h_L` in degrees.\n\n Examples\n --------\n >>> hue_angle(-4.49864756e-03, -5.26046353e-03) # doctest: +ELLIPSIS\n 229.4635727...\n \"\"\"\n\n a = as_float_array(a)\n b = as_float_array(b)\n\n h_L = np.degrees(np.arctan2(b, a)) % 360\n\n return h_L\n\n\ndef chroma_correlate(a, b):\n \"\"\"\n Returns the correlate of *chroma* :math:`Ch_L`.\n\n Parameters\n ----------\n a : numeric or array_like\n Opponent colour dimension :math:`a`.\n b : numeric or array_like\n Opponent colour dimension :math:`b`.\n\n Returns\n -------\n numeric or ndarray\n Correlate of *chroma* :math:`Ch_L`.\n\n Examples\n --------\n >>> a = -4.49864756e-03\n >>> b = -5.26046353e-03\n >>> chroma_correlate(a, b) # doctest: +ELLIPSIS\n 0.0086506...\n \"\"\"\n\n a = as_float_array(a)\n b = as_float_array(b)\n\n c = spow(a ** 2 + b ** 2, 0.5)\n Ch_L = 25 * np.log(1 + 0.05 * c)\n\n return Ch_L\n\n\ndef colourfulness_correlate(L, L_L, Ch_L, F_C):\n \"\"\"\n Returns the correlate of *colourfulness* :math:`C_L`.\n\n Parameters\n ----------\n L : numeric or array_like\n Absolute luminance :math:`L` of reference white in :math:`cd/m^2`.\n L_L : numeric or array_like\n Correlate of *Lightness* :math:`L_L`.\n Ch_L : numeric or array_like\n Correlate of *chroma* :math:`Ch_L`.\n F_C : numeric or array_like\n Chroma induction factor :math:`F_C`.\n\n Returns\n -------\n numeric or ndarray\n Correlate of *colourfulness* :math:`C_L`.\n\n Examples\n --------\n >>> L = 318.31\n >>> L_L = 37.368047493928195\n >>> Ch_L = 0.008650662051714\n >>> F_C = 1.0\n >>> colourfulness_correlate(L, L_L, Ch_L, F_C) # doctest: +ELLIPSIS\n 0.0183832...\n \"\"\"\n\n L = as_float_array(L)\n L_L = as_float_array(L_L)\n Ch_L = as_float_array(Ch_L)\n F_C = as_float_array(F_C)\n\n S_C = 1 + 0.47 * np.log10(L) - 0.057 * np.log10(L) ** 2\n S_M = 0.7 + 0.02 * L_L - 0.0002 * L_L ** 2\n C_L = Ch_L * S_M * S_C * F_C\n\n return C_L\n\n\ndef saturation_correlate(Ch_L, L_L):\n \"\"\"\n Returns the correlate of *saturation* :math:`S_L`.\n\n Parameters\n ----------\n Ch_L : numeric or array_like\n Correlate of *chroma* :math:`Ch_L`.\n L_L : numeric or array_like\n Correlate of *Lightness* :math:`L_L`.\n\n Returns\n -------\n numeric or ndarray\n Correlate of *saturation* :math:`S_L`.\n\n Examples\n --------\n >>> Ch_L = 0.008650662051714\n >>> L_L = 37.368047493928195\n >>> saturation_correlate(Ch_L, L_L) # doctest: +ELLIPSIS\n 0.0002314...\n \"\"\"\n\n Ch_L = as_float_array(Ch_L)\n L_L = as_float_array(L_L)\n\n S_L = Ch_L / L_L\n\n return S_L\n\n\ndef final_opponent_signals(C_L, h_L):\n \"\"\"\n Returns the final opponent signals :math:`A_L` and :math:`B_L`.\n\n Parameters\n ----------\n C_L : numeric or array_like\n Correlate of *colourfulness* :math:`C_L`.\n h_L : numeric or array_like\n Correlate of *hue* :math:`h_L` in degrees.\n\n Returns\n -------\n ndarray\n Final opponent signals :math:`A_L` and :math:`B_L`.\n\n Examples\n --------\n >>> C_L = 0.0183832899143\n >>> h_L = 229.46357270858391\n >>> final_opponent_signals(C_L, h_L) # doctest: +ELLIPSIS\n array([-0.0119478..., -0.0139711...])\n \"\"\"\n\n AB_L = polar_to_cartesian(tstack([C_L, np.radians(h_L)]))\n\n return AB_L\n"
] | [
[
"numpy.array"
],
[
"numpy.maximum"
],
[
"numpy.array",
"numpy.tile",
"numpy.reshape"
],
[
"numpy.asarray",
"numpy.errstate"
],
[
"numpy.array",
"numpy.log",
"numpy.radians",
"numpy.arctan2",
"numpy.log10",
"numpy.linalg.inv"
]
] |
NestLakerJasonLIN/pipedream | [
"cad624f79a71f44ba79099f0c38321347b13e5c2",
"cad624f79a71f44ba79099f0c38321347b13e5c2"
] | [
"profiler/torchmodules/torchlogger/activation_gradient_logger.py",
"runtime/image_classification/models/vgg16/gpus=16_straight/stage5.py"
] | [
"# Copyright (c) Microsoft Corporation.\n# Licensed under the MIT license.\n\nimport os\nimport pickle\nimport torch\n\n\nclass ActivationAndGradientLogger:\n def __init__(self, directory):\n self.directory = directory\n try:\n os.mkdir(self.directory)\n except:\n pass\n self.iteration = 0\n self.forward_counter = 0\n self.backward_counter = 0\n\n def reset_counters(self):\n self.forward_counter = 0\n self.backward_counter = 0\n\n def hook_modules(self, module, iteration):\n self.iteration = iteration\n sub_directory = os.path.join(self.directory, str(iteration))\n try:\n os.mkdir(sub_directory)\n except:\n pass\n self.hook_modules_helper(module, sub_directory)\n\n def hook_modules_helper(self, module, sub_directory):\n sub_modules = module.__dict__['_modules']\n\n for name, sub_module in sub_modules.items():\n if sub_module is None or isinstance(sub_module, torch.nn.Module) is False:\n break\n\n sub_sub_modules = sub_module.__dict__['_modules']\n if len(sub_sub_modules) > 0:\n # Recursively visit this module's descendants.\n self.hook_modules_helper(sub_module, sub_directory)\n else:\n def forward_hook(*args):\n activation = args[2]\n filename = os.path.join(sub_directory, 'activations.%d.pkl' % self.forward_counter)\n with open(filename, 'wb') as f:\n torch.save(activation, f)\n self.forward_counter += 1\n\n def backward_hook(*args):\n gradient = args[2]\n filename = os.path.join(sub_directory, 'gradients.%d.pkl' % self.backward_counter)\n with open(filename, 'wb') as f:\n torch.save(gradient, f)\n self.backward_counter += 1\n\n sub_module.register_forward_hook(forward_hook)\n sub_module.register_backward_hook(backward_hook)\n\n def unhook_modules(self, module):\n self.unhook_modules_helper(module)\n self.reset_counters()\n\n def unhook_modules_helper(self, module):\n sub_modules = module.__dict__['_modules']\n\n for name, sub_module in sub_modules.items():\n if sub_module is None or isinstance(sub_module, torch.nn.Module) is False:\n break\n\n sub_sub_modules = sub_module.__dict__['_modules']\n if len(sub_sub_modules) > 0:\n # Recursively visit this module's descendants.\n self.unhook_modules_helper(sub_module)\n else:\n sub_module.reset_hooks()\n",
"# Copyright (c) Microsoft Corporation.\n# Licensed under the MIT license.\n\nimport torch\n\n\nclass Stage5(torch.nn.Module):\n def __init__(self):\n super(Stage5, self).__init__()\n self.layer1 = torch.nn.Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n self._initialize_weights()\n\n def forward(self, input0):\n out0 = input0.clone()\n out1 = self.layer1(out0)\n return out1\n\n def _initialize_weights(self):\n for m in self.modules():\n if isinstance(m, torch.nn.Conv2d):\n torch.nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n if m.bias is not None:\n torch.nn.init.constant_(m.bias, 0)\n elif isinstance(m, torch.nn.BatchNorm2d):\n torch.nn.init.constant_(m.weight, 1)\n torch.nn.init.constant_(m.bias, 0)\n elif isinstance(m, torch.nn.Linear):\n torch.nn.init.normal_(m.weight, 0, 0.01)\n torch.nn.init.constant_(m.bias, 0)\n"
] | [
[
"torch.save"
],
[
"torch.nn.Conv2d",
"torch.nn.init.kaiming_normal_",
"torch.nn.init.normal_",
"torch.nn.init.constant_"
]
] |
PriyamvadaKumar/AWS_BioActive_Classification | [
"b6a4413618586712ca4dc196f2dfaa3ceca804fb"
] | [
"bioactive_lab.py"
] | [
"import os, sys\ndirpath = os.getcwd()\nsys.path.insert(0, dirpath + '/goal_tether_functions')\nsys.path.insert(0, dirpath + '/predictive_modelers')\nsys.path.insert(0, dirpath + '/predictive_modelers/assessment_resources')\nsys.path.insert(0, dirpath + '/active_learners')\nsys.path.insert(0, dirpath + '/data_acquisition')\nsys.path.insert(0, dirpath + '/diagnostics')\nfrom createCampaign_battleship import main as createCampaign\n# from createImageCampaign_Bria import main as createCampaign\nfrom runCampaign2 import main as runCampaign\nfrom database import *\nimport outputManager\nimport time\nimport boto3\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport numpy as np\nfrom sklearn.preprocessing import LabelEncoder\nfrom sklearn.cluster import KMeans\n\n\n# Part 1 Plotting Function\ndef plot_simulation_accuracy(acc, title, mul_accuracy=False):\n fig, ax = plt.subplots()\n ax.set_ylabel(\"Accuracy (%)\")\n ax.set_xlabel(\"Iterations\")\n ax.set_title(title)\n if mul_accuracy:\n ax.plot(np.arange(len(acc[0])), acc[0], label=\"Full Space\")\n ax.plot(np.arange(len(acc[1])), acc[1], label=\"Forward Modeling\")\n ax.plot(np.arange(len(acc[2])), acc[2], label=\"Prediction Only\")\n else:\n ax.plot(np.arange(len(acc)), acc)\n ax.legend()\n plt.show()\n\n\ndef average_arrays(mat):\n array = []\n for i in range(25):\n avg = 0\n for m in range(len(mat)):\n if len(mat[m]) < i:\n continue\n avg += mat[m][i]\n avg = avg/len(mat)\n array.append(avg)\n return array\n\nwd =os.getcwd()\nprint(\"Current Working Directory: \", wd)\nprint()\n\nif path.exists(\"data/data.csv\") is False:\n print(\"Retrieving Data from S3\")\n\n# read data from S3\ns3 = boto3.resource('s3')\ns3.Bucket('whatyouknowaboutmybucket').download_file('data.csv', wd + '/data/data.csv')\n\nif path.exists(\"data/data.csv\") is False:\n print(\"Retrieving Data from S3\")\n time.sleep(5)\n\ndata = pd.read_csv(\"data/data.csv\").dropna().to_numpy()\nfeatures = data[:, 4:]\nlabels = data[:, 2]\n\nl = LabelEncoder()\nlabels = l.fit_transform(labels)\nprint(l.classes_)\n\ns = KMeans(n_clusters=5)\n# s.decision_function(features[:1000])\ns.fit_transform(features[:1500])\nprint(s.score(features[1500:]))\n\nd = np.zeros((20,20))\n\n# create groundTruth\nfor i in range(len(data)):\n if data[i][0] - 1 >= len(d) or data[i][1] >= len(d[0]):\n continue\n d[data[i][0]-1][data[i][1]-1] = s.predict(features[i].reshape(1,-1))\n\nprint(d)\n\n\nnp.savetxt('data_acquisition/project.txt', d)\n\n\nprint(labels)\n\n\n\n\n\n\n# exit()\n'''\ncampaign = createCampaign()\nrunCampaign(campaign)\nacc = [np.array(campaign.accuracy_full), np.array(campaign.accuracy_forwardModeling),\n np.array(campaign.accuracy_onlyPredictions)]\n\nplot_simulation_accuracy(acc, \"Model Accuracies for a Single Simulation\", mul_accuracy=True)\n'''\n\n# Part 2 of Assignment - 2 independent variables (0-20) and 1 dependent variable (0-10) for 20 simulations\n\nacc = []\nfor i in range(1):\n campaign = createCampaign()\n campaign.randoseed = 2\n # campaign.ESS.iVars = [('int', 0, 9), ('int', 0, 9)]\n # campaign.ESS.dVars = [('int', 0, 2)]\n campaign.groundtruthData = 'data_acquisition/project.txt'\n campaign.simsFlag = True\n runCampaign(campaign)\n acc = [campaign.accuracy_full, campaign.accuracy_forwardModeling, campaign.accuracy_onlyPredictions]\n# acc = average_arrays(acc)\nplot_simulation_accuracy(acc, \"Three Accuracies for the Experimental Space\", mul_accuracy=True)\n\n\n# Part 3 of Assignment -\n# acc1, acc2, acc3, acc4 = [], [], [], []\n# for i in range(5):\n# campaign = createCampaign()\n# campaign.ESS.high_homogeneity = True\n# campaign.ESS.h_num = 2\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 2)]\n# campaign.ESS.dimarr = [20,20]\n# runCampaign(campaign)\n# acc = campaign.accuracy_onlyPredictions\n# acc1.append(acc)\n#\n# for i in range(5):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.h_num = 2\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 2)]\n# runCampaign(campaign)\n# acc = campaign.accuracy_onlyPredictions\n# acc2.append(acc)\n#\n# for i in range(5):\n# campaign = createCampaign()\n# campaign.ESS.high_homogeneity = True\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20,20]\n# runCampaign(campaign)\n# acc = campaign.accuracy_onlyPredictions\n# acc3.append(acc)\n#\n# for i in range(5):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20,20]\n# runCampaign(campaign)\n# acc = campaign.accuracy_onlyPredictions\n# acc4.append(acc)\n#\n# acc1, acc2, acc3, acc4 = average_arrays(acc1), average_arrays(acc2), average_arrays(acc3), average_arrays(acc4)\n#\n# plt.plot([i+1 for i in range(len(acc1))], acc1, label=\"H-2\", color=\"blue\")\n# plt.plot([i+1 for i in range(len(acc2))], acc2, label=\"L-2\", color=\"green\")\n# plt.plot([i+1 for i in range(len(acc3))], acc3, label=\"H-10\", color=\"red\")\n# plt.plot([i+1 for i in range(len(acc4))], acc4, label=\"L-10\", color=\"black\")\n# plt.ylabel(\"Accuracy (%)\")\n# plt.xlabel(\"Iterations\")\n# plt.title(\"Different Homogeneity within Experimental Spaces\")\n# plt.legend()\n# plt.show()\n\n\n# Part 4 of Assignment -\n\n# acc1, acc2, acc3, acc4 = [], [], [], []\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.ESS.error = 0\n# campaign.randoseed= 45\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc = campaign.accuracy_onlyPredictions\n# acc1.append(acc)\n#\n#\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.randoseed = 1\n# campaign.ESS.error = 0.1\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc = campaign.accuracy_onlyPredictions\n# acc2.append(acc)\n#\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.ESS.error = 0.5\n# campaign.randoseed = 2\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc = campaign.accuracy_onlyPredictions\n# acc3.append(acc)\n#\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.ESS.error = 1.0\n# campaign.randoseed=3\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc = campaign.accuracy_onlyPredictions\n# acc4.append(acc)\n#\n# acc1, acc2, acc3, acc4 = average_arrays(acc1), average_arrays(acc2), average_arrays(acc3), average_arrays(acc4)\n#\n# plt.plot([i+1 for i in range(len(acc1))], acc1, label=\"0.0\", color=\"blue\")\n# plt.plot([i+1 for i in range(len(acc2))], acc2, label=\"0.1\", color=\"green\")\n# plt.plot([i+1 for i in range(len(acc3))], acc3, label=\"0.5\", color=\"red\")\n# plt.plot([i+1 for i in range(len(acc4))], acc4, label=\"1.0\", color=\"black\")\n# plt.ylabel(\"Accuracy (%)\")\n# plt.xlabel(\"Iterations\")\n# plt.title(\"Different Error Rates within Experimental Spaces\")\n# plt.legend()\n# plt.show()\n\n\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.ESS.error = 0\n# campaign.randoseed = 53\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc1 = campaign.accuracy_onlyPredictions\n#\n#\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.ESS.error = 0\n# campaign.randoseed = 39\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc2 = campaign.accuracy_onlyPredictions\n#\n#\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.ESS.error = 0.1\n# campaign.randoseed = 32\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc3 = campaign.accuracy_onlyPredictions\n#\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.ESS.error = 0.1\n# campaign.randoseed = 17\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc4 = campaign.accuracy_onlyPredictions\n#\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.ESS.error = 0.5\n# campaign.randoseed = 3\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc5 = campaign.accuracy_onlyPredictions\n#\n# for i in range(1):\n# campaign = createCampaign()\n# campaign.ESS.low_homogeneity = True\n# campaign.ESS.error = True\n# campaign.ESS.error = 0.5\n# campaign.randoseed = 15\n# campaign.ESS.h_num = 10\n# campaign.ESS.iVars = [('int', 0, 19), ('int', 0, 19)]\n# campaign.ESS.dVars = [('int', 0, 9)]\n# campaign.ESS.dimarr = [20, 20]\n# runCampaign(campaign)\n# print(campaign.groundTruth)\n# acc6 = campaign.accuracy_onlyPredictions\n#\n#\n# plt.plot([i+1 for i in range(len(acc1))], acc1, label=\"0.0 - B\", color=\"blue\")\n# plt.plot([i+1 for i in range(len(acc2))], acc2, label=\"0.0 - N\", color=\"green\")\n# plt.plot([i+1 for i in range(len(acc3))], acc3, label=\"0.1 - B\", color=\"red\")\n# plt.plot([i+1 for i in range(len(acc4))], acc4, label=\"0.1 - N\", color=\"black\")\n# plt.plot([i+1 for i in range(len(acc5))], acc5, label=\"0.5 - B\", color=\"yellow\")\n# plt.plot([i+1 for i in range(len(acc6))], acc6, label=\"0.5 - N\", color=\"cyan\")\n# plt.ylabel(\"Accuracy (%)\")\n# plt.xlabel(\"Iterations\")\n# plt.title(\"Different Categorical Models within Experimental Spaces\")\n# plt.legend()\n# plt.show()\n"
] | [
[
"sklearn.preprocessing.LabelEncoder",
"numpy.savetxt",
"numpy.zeros",
"sklearn.cluster.KMeans",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show",
"pandas.read_csv"
]
] |
polewczakp/pyAudioAnalysis | [
"7dc2d8e18da1ca2f2485a402bb7399b43bbb2b24"
] | [
"pyAudioAnalysis/audioSegmentation.py"
] | [
"from __future__ import print_function\nimport os\nimport csv\nimport glob\nimport scipy\nimport sklearn\nimport numpy as np\nimport hmmlearn.hmm\nimport sklearn.cluster\nimport pickle as cpickle\nimport matplotlib.pyplot as plt\nfrom scipy.spatial import distance\nimport sklearn.discriminant_analysis\nfrom pyAudioAnalysis import audioBasicIO\nfrom pyAudioAnalysis import audioTrainTest as at\nfrom pyAudioAnalysis import MidTermFeatures as mtf\nfrom pyAudioAnalysis import ShortTermFeatures as stf\n\n\"\"\" General utility functions \"\"\"\n\n\ndef smooth_moving_avg(signal, window=11):\n window = int(window)\n if signal.ndim != 1:\n raise ValueError(\"\")\n if signal.size < window:\n raise ValueError(\"Input vector needs to be bigger than window size.\")\n if window < 3:\n return signal\n s = np.r_[2 * signal[0] - signal[window - 1::-1],\n signal, 2 * signal[-1] - signal[-1:-window:-1]]\n w = np.ones(window, 'd')\n y = np.convolve(w/w.sum(), s, mode='same')\n return y[window:-window + 1]\n\n\ndef self_similarity_matrix(feature_vectors):\n \"\"\"\n This function computes the self-similarity matrix for a sequence\n of feature vectors.\n ARGUMENTS:\n - feature_vectors: a np matrix (nDims x nVectors) whose i-th column\n corresponds to the i-th feature vector\n\n RETURNS:\n - sim_matrix: the self-similarity matrix (nVectors x nVectors)\n \"\"\"\n norm_feature_vectors, mean, std = at.normalize_features([feature_vectors.T])\n norm_feature_vectors = norm_feature_vectors[0].T\n sim_matrix = 1.0 - distance.squareform(\n distance.pdist(norm_feature_vectors.T, 'cosine'))\n return sim_matrix\n\n\ndef labels_to_segments(labels, window):\n \"\"\"\n ARGUMENTS:\n - labels: a sequence of class labels (per time window)\n - window: window duration (in seconds)\n\n RETURNS:\n - segments: a sequence of segment's limits: segs[i, 0] is start and\n segs[i, 1] are start and end point of segment i\n - classes: a sequence of class flags: class[i] is the class ID of\n the i-th segment\n \"\"\"\n\n if len(labels)==1:\n segs = [0, window]\n classes = labels\n return segs, classes\n\n\n num_segs = 0\n index = 0\n classes = []\n segment_list = []\n cur_label = labels[index]\n while index < len(labels) - 1:\n previous_value = cur_label\n while True:\n index += 1\n compare_flag = labels[index]\n if (compare_flag != cur_label) | (index == len(labels) - 1):\n num_segs += 1\n cur_label = labels[index]\n segment_list.append((index * window))\n classes.append(previous_value)\n break\n segments = np.zeros((len(segment_list), 2))\n\n for i in range(len(segment_list)):\n if i > 0:\n segments[i, 0] = segment_list[i-1]\n segments[i, 1] = segment_list[i]\n return segments, classes\n\n\ndef segments_to_labels(start_times, end_times, labels, window):\n \"\"\"\n This function converts segment endpoints and respective segment\n labels to fix-sized class labels.\n ARGUMENTS:\n - start_times: segment start points (in seconds)\n - end_times: segment endpoints (in seconds)\n - labels: segment labels\n - window: fix-sized window (in seconds)\n RETURNS:\n - flags: np array of class indices\n - class_names: list of classnames (strings)\n \"\"\"\n flags = []\n class_names = list(set(labels))\n index = window / 2.0\n while index < end_times[-1]:\n for i in range(len(start_times)):\n if start_times[i] < index <= end_times[i]:\n break\n flags.append(class_names.index(labels[i]))\n index += window\n return np.array(flags), class_names\n\n\ndef compute_metrics(confusion_matrix, class_names):\n \"\"\"\n This function computes the precision, recall and f1 measures,\n given a confusion matrix\n \"\"\"\n f1 = []\n recall = []\n precision = []\n n_classes = confusion_matrix.shape[0]\n if len(class_names) != n_classes:\n print(\"Error in computePreRec! Confusion matrix and class_names \"\n \"list must be of the same size!\")\n else:\n for i, c in enumerate(class_names):\n precision.append(confusion_matrix[i, i] /\n np.sum(confusion_matrix[:, i]))\n recall.append(confusion_matrix[i, i] /\n np.sum(confusion_matrix[i, :]))\n f1.append(2 * precision[-1] * recall[-1] /\n (precision[-1] + recall[-1]))\n return recall, precision, f1\n\n\ndef read_segmentation_gt(gt_file):\n \"\"\"\n This function reads a segmentation ground truth file,\n following a simple CSV format with the following columns:\n <segment start>,<segment end>,<class label>\n\n ARGUMENTS:\n - gt_file: the path of the CSV segment file\n RETURNS:\n - seg_start: a np array of segments' start positions\n - seg_end: a np array of segments' ending positions\n - seg_label: a list of respective class labels (strings)\n \"\"\"\n with open(gt_file, 'rt') as f_handle:\n reader = csv.reader(f_handle, delimiter='\\t')\n start_times = []\n end_times = []\n labels = []\n for row in reader:\n if len(row) == 3:\n start_times.append(float(row[0]))\n end_times.append(float(row[1]))\n labels.append((row[2]))\n return np.array(start_times), np.array(end_times), labels\n\n\ndef plot_segmentation_results(flags_ind, flags_ind_gt, class_names, mt_step,\n evaluate_only=False):\n \"\"\"\n This function plots statistics on the classification-segmentation results \n produced either by the fix-sized supervised method or the HMM method.\n It also computes the overall accuracy achieved by the respective method \n if ground-truth is available.\n \"\"\"\n \n flags = [class_names[int(f)] for f in flags_ind]\n segments, classes = labels_to_segments(flags, mt_step)\n min_len = min(flags_ind.shape[0], flags_ind_gt.shape[0]) \n if min_len > 0:\n accuracy = np.sum(flags_ind[0:min_len] ==\n flags_ind_gt[0:min_len]) / float(min_len)\n else:\n accuracy = -1\n\n if not evaluate_only:\n duration = segments[-1, 1]\n s_percentages = np.zeros((len(class_names), ))\n percentages = np.zeros((len(class_names), ))\n av_durations = np.zeros((len(class_names), ))\n\n for i_seg in range(segments.shape[0]):\n s_percentages[class_names.index(classes[i_seg])] += \\\n (segments[i_seg, 1]-segments[i_seg, 0])\n\n for i in range(s_percentages.shape[0]):\n percentages[i] = 100.0 * s_percentages[i] / duration\n class_sum = sum(1 for c in classes if c == class_names[i])\n if class_sum > 0:\n av_durations[i] = s_percentages[i] / class_sum\n else:\n av_durations[i] = 0.0\n\n for i in range(percentages.shape[0]):\n print(class_names[i], percentages[i], av_durations[i])\n\n font = {'size': 10}\n plt.rc('font', **font)\n\n fig = plt.figure()\n ax1 = fig.add_subplot(211)\n ax1.set_yticks(np.array(range(len(class_names))))\n ax1.axis((0, duration, -1, len(class_names)))\n ax1.set_yticklabels(class_names)\n ax1.plot(np.array(range(len(flags_ind))) * mt_step +\n mt_step / 2.0, flags_ind)\n if flags_ind_gt.shape[0] > 0:\n ax1.plot(np.array(range(len(flags_ind_gt))) * mt_step +\n mt_step / 2.0, flags_ind_gt + 0.05, '--r')\n plt.xlabel(\"time (seconds)\")\n if accuracy >= 0:\n plt.title('Accuracy = {0:.1f}%'.format(100.0 * accuracy))\n\n ax2 = fig.add_subplot(223)\n plt.title(\"Classes percentage durations\")\n ax2.axis((0, len(class_names) + 1, 0, 100))\n ax2.set_xticks(np.array(range(len(class_names) + 1)))\n ax2.set_xticklabels([\" \"] + class_names)\n print(np.array(range(len(class_names))), percentages)\n ax2.bar(np.array(range(len(class_names))) + 0.5, percentages)\n\n ax3 = fig.add_subplot(224)\n plt.title(\"Segment average duration per class\")\n ax3.axis((0, len(class_names)+1, 0, av_durations.max()))\n ax3.set_xticks(np.array(range(len(class_names) + 1)))\n ax3.set_xticklabels([\" \"] + class_names)\n ax3.bar(np.array(range(len(class_names))) + 0.5, av_durations)\n fig.tight_layout()\n plt.show()\n return accuracy\n\n\ndef evaluate_speaker_diarization(labels, labels_gt):\n\n min_len = min(labels.shape[0], labels_gt.shape[0])\n labels = labels[0:min_len]\n labels_gt = labels_gt[0:min_len]\n\n unique_flags = np.unique(labels)\n unique_flags_gt = np.unique(labels_gt)\n\n # compute contigency table:\n contigency_matrix = np.zeros((unique_flags.shape[0],\n unique_flags_gt.shape[0]))\n for i in range(min_len):\n contigency_matrix[int(np.nonzero(unique_flags == labels[i])[0]),\n int(np.nonzero(unique_flags_gt == labels_gt[i])[0])] += 1.0\n\n columns, rows = contigency_matrix.shape\n row_sum = np.sum(contigency_matrix, axis=0)\n column_sum = np.sum(contigency_matrix, axis=1)\n matrix_sum = np.sum(contigency_matrix)\n\n purity_clust = np.zeros((columns, ))\n purity_speak = np.zeros((rows, ))\n # compute cluster purity:\n for i in range(columns):\n purity_clust[i] = np.max((contigency_matrix[i, :])) / (column_sum[i])\n\n for j in range(rows):\n purity_speak[j] = np.max((contigency_matrix[:, j])) / (row_sum[j])\n\n purity_cluster_m = np.sum(purity_clust * column_sum) / matrix_sum\n purity_speaker_m = np.sum(purity_speak * row_sum) / matrix_sum\n\n return purity_cluster_m, purity_speaker_m\n\n\ndef train_hmm_compute_statistics(features, labels):\n \"\"\"\n This function computes the statistics used to train\n an HMM joint segmentation-classification model\n using a sequence of sequential features and respective labels\n\n ARGUMENTS:\n - features: a np matrix of feature vectors (numOfDimensions x n_wins)\n - labels: a np array of class indices (n_wins x 1)\n RETURNS:\n - class_priors: matrix of prior class probabilities\n (n_classes x 1)\n - transmutation_matrix: transition matrix (n_classes x n_classes)\n - means: means matrix (numOfDimensions x 1)\n - cov: deviation matrix (numOfDimensions x 1)\n \"\"\"\n unique_labels = np.unique(labels)\n n_comps = len(unique_labels)\n\n n_feats = features.shape[0]\n\n if features.shape[1] < labels.shape[0]:\n print(\"trainHMM warning: number of short-term feature vectors \"\n \"must be greater or equal to the labels length!\")\n labels = labels[0:features.shape[1]]\n\n # compute prior probabilities:\n class_priors = np.zeros((n_comps,))\n for i, u_label in enumerate(unique_labels):\n class_priors[i] = np.count_nonzero(labels == u_label)\n # normalize prior probabilities\n class_priors = class_priors / class_priors.sum()\n\n # compute transition matrix:\n transmutation_matrix = np.zeros((n_comps, n_comps))\n for i in range(labels.shape[0]-1):\n transmutation_matrix[int(labels[i]), int(labels[i + 1])] += 1\n # normalize rows of transition matrix:\n for i in range(n_comps):\n transmutation_matrix[i, :] /= transmutation_matrix[i, :].sum()\n\n means = np.zeros((n_comps, n_feats))\n for i in range(n_comps):\n means[i, :] = \\\n np.array(features[:,\n np.nonzero(labels == unique_labels[i])[0]].mean(axis=1))\n\n cov = np.zeros((n_comps, n_feats))\n for i in range(n_comps):\n \"\"\"\n cov[i, :, :] = np.cov(features[:, np.nonzero(labels == u_labels[i])[0]])\n \"\"\"\n # use line above if HMM using full gaussian distributions are to be used\n cov[i, :] = np.std(features[:,\n np.nonzero(labels == unique_labels[i])[0]],\n axis=1)\n\n return class_priors, transmutation_matrix, means, cov\n\n\ndef train_hmm_from_file(wav_file, gt_file, hmm_model_name, mid_window, mid_step):\n \"\"\"\n This function trains a HMM model for segmentation-classification\n using a single annotated audio file\n ARGUMENTS:\n - wav_file: the path of the audio filename\n - gt_file: the path of the ground truth filename\n (a csv file of the form <segment start in seconds>,\n <segment end in seconds>,<segment label> in each row\n - hmm_model_name: the name of the HMM model to be stored\n - mt_win: mid-term window size\n - mt_step: mid-term window step\n RETURNS:\n - hmm: an object to the resulting HMM\n - class_names: a list of class_names\n\n After training, hmm, class_names, along with the mt_win and mt_step\n values are stored in the hmm_model_name file\n \"\"\"\n\n seg_start, seg_end, seg_labs = read_segmentation_gt(gt_file)\n flags, class_names = segments_to_labels(seg_start, seg_end, seg_labs, mid_step)\n sampling_rate, signal = audioBasicIO.read_audio_file(wav_file)\n features, _, _ = \\\n mtf.mid_feature_extraction(signal, sampling_rate,\n mid_window * sampling_rate,\n mid_step * sampling_rate,\n round(sampling_rate * 0.050),\n round(sampling_rate * 0.050))\n class_priors, transumation_matrix, means, cov = \\\n train_hmm_compute_statistics(features, flags)\n hmm = hmmlearn.hmm.GaussianHMM(class_priors.shape[0], \"diag\")\n\n hmm.covars_ = cov\n hmm.means_ = means\n hmm.startprob_ = class_priors\n hmm.transmat_ = transumation_matrix\n\n save_hmm(hmm_model_name, hmm, class_names, mid_window, mid_step)\n\n return hmm, class_names\n\n\ndef train_hmm_from_directory(folder_path, hmm_model_name, mid_window, mid_step):\n \"\"\"\n This function trains a HMM model for segmentation-classification using\n a where WAV files and .segment (ground-truth files) are stored\n ARGUMENTS:\n - folder_path: the path of the data diretory\n - hmm_model_name: the name of the HMM model to be stored\n - mt_win: mid-term window size\n - mt_step: mid-term window step\n RETURNS:\n - hmm: an object to the resulting HMM\n - class_names: a list of class_names\n\n After training, hmm, class_names, along with the mt_win\n and mt_step values are stored in the hmm_model_name file\n \"\"\"\n\n flags_all = np.array([])\n class_names_all = []\n for i, f in enumerate(glob.glob(folder_path + os.sep + '*.wav')):\n # for each WAV file\n wav_file = f\n gt_file = f.replace('.wav', '.segments')\n if os.path.isfile(gt_file):\n seg_start, seg_end, seg_labs = read_segmentation_gt(gt_file)\n flags, class_names = \\\n segments_to_labels(seg_start, seg_end, seg_labs, mid_step)\n for c in class_names:\n # update class names:\n if c not in class_names_all:\n class_names_all.append(c)\n sampling_rate, signal = audioBasicIO.read_audio_file(wav_file)\n feature_vector, _, _ = \\\n mtf.mid_feature_extraction(signal, sampling_rate,\n mid_window * sampling_rate,\n mid_step * sampling_rate,\n round(sampling_rate * 0.050),\n round(sampling_rate * 0.050))\n\n flag_len = len(flags)\n feat_cols = feature_vector.shape[1]\n min_sm = min(feat_cols, flag_len)\n feature_vector = feature_vector[:, 0:min_sm]\n flags = flags[0:min_sm]\n\n flags_new = []\n # append features and labels\n for j, fl in enumerate(flags):\n flags_new.append(class_names_all.index(class_names_all[flags[j]]))\n\n flags_all = np.append(flags_all, np.array(flags_new))\n\n if i == 0:\n f_all = feature_vector\n else:\n f_all = np.concatenate((f_all, feature_vector), axis=1)\n\n # compute HMM statistics\n class_priors, transmutation_matrix, means, cov = \\\n train_hmm_compute_statistics(f_all, flags_all)\n # train the HMM\n hmm = hmmlearn.hmm.GaussianHMM(class_priors.shape[0], \"diag\")\n hmm.covars_ = cov\n hmm.means_ = means\n hmm.startprob_ = class_priors\n hmm.transmat_ = transmutation_matrix\n\n save_hmm(hmm_model_name, hmm, class_names_all, mid_window, mid_step)\n\n return hmm, class_names_all\n\n\ndef save_hmm(hmm_model_name, model, classes, mid_window, mid_step):\n \"\"\"Save HMM model\"\"\"\n with open(hmm_model_name, \"wb\") as f_handle:\n cpickle.dump(model, f_handle, protocol=cpickle.HIGHEST_PROTOCOL)\n cpickle.dump(classes, f_handle, protocol=cpickle.HIGHEST_PROTOCOL)\n cpickle.dump(mid_window, f_handle, protocol=cpickle.HIGHEST_PROTOCOL)\n cpickle.dump(mid_step, f_handle, protocol=cpickle.HIGHEST_PROTOCOL)\n\n\ndef hmm_segmentation(audio_file, hmm_model_name, plot_results=False,\n gt_file=\"\"):\n sampling_rate, signal = audioBasicIO.read_audio_file(audio_file)\n\n with open(hmm_model_name, \"rb\") as f_handle:\n hmm = cpickle.load(f_handle)\n class_names = cpickle.load(f_handle)\n mid_window = cpickle.load(f_handle)\n mid_step = cpickle.load(f_handle)\n\n features, _, _ = \\\n mtf.mid_feature_extraction(signal, sampling_rate,\n mid_window * sampling_rate,\n mid_step * sampling_rate,\n round(sampling_rate * 0.050),\n round(sampling_rate * 0.050))\n\n # apply model\n labels = hmm.predict(features.T)\n labels_gt, class_names_gt, accuracy, cm = \\\n load_ground_truth(gt_file, labels, class_names, mid_step, plot_results)\n return labels, class_names, accuracy, cm\n\n\ndef load_ground_truth_segments(gt_file, mt_step):\n seg_start, seg_end, seg_labels = read_segmentation_gt(gt_file)\n labels, class_names = segments_to_labels(seg_start, seg_end, seg_labels,\n mt_step)\n labels_temp = []\n for index, label in enumerate(labels):\n # \"align\" labels with GT\n if class_names[labels[index]] in class_names:\n labels_temp.append(class_names.index(class_names[\n labels[index]]))\n else:\n labels_temp.append(-1)\n labels = np.array(labels_temp)\n return labels, class_names\n\n\ndef calculate_confusion_matrix(predictions, ground_truth, classes):\n cm = np.zeros((len(classes), len(classes)))\n for index in range(min(predictions.shape[0], ground_truth.shape[0])):\n cm[int(ground_truth[index]), int(predictions[index])] += 1\n return cm\n\n\ndef mid_term_file_classification(input_file, model_name, model_type,\n plot_results=False, gt_file=\"\"):\n \"\"\"\n This function performs mid-term classification of an audio stream.\n Towards this end, supervised knowledge is used,\n i.e. a pre-trained classifier.\n ARGUMENTS:\n - input_file: path of the input WAV file\n - model_name: name of the classification model\n - model_type: svm or knn depending on the classifier type\n - plot_results: True if results are to be plotted using\n matplotlib along with a set of statistics\n\n RETURNS:\n - segs: a sequence of segment's endpoints: segs[i] is the\n endpoint of the i-th segment (in seconds)\n - classes: a sequence of class flags: class[i] is the\n class ID of the i-th segment\n \"\"\"\n labels = []\n accuracy = 0.0\n class_names = []\n cm = np.array([])\n if not os.path.isfile(model_name):\n print(\"mtFileClassificationError: input model_type not found!\")\n return labels, class_names, accuracy, cm\n\n # Load classifier:\n if model_type == \"knn\":\n classifier, mean, std, class_names, mt_win, mid_step, st_win, \\\n st_step, compute_beat = at.load_model_knn(model_name)\n else:\n classifier, mean, std, class_names, mt_win, mid_step, st_win, \\\n st_step, compute_beat = at.load_model(model_name)\n if compute_beat:\n print(\"Model \" + model_name + \" contains long-term music features \"\n \"(beat etc) and cannot be used in \"\n \"segmentation\")\n return labels, class_names, accuracy, cm\n # load input file\n sampling_rate, signal = audioBasicIO.read_audio_file(input_file)\n\n # could not read file\n if sampling_rate == 0:\n return labels, class_names, accuracy, cm\n\n # convert stereo (if) to mono\n signal = audioBasicIO.stereo_to_mono(signal)\n\n # mid-term feature extraction:\n mt_feats, _, _ = \\\n mtf.mid_feature_extraction(signal, sampling_rate,\n mt_win * sampling_rate,\n mid_step * sampling_rate,\n round(sampling_rate * st_win),\n round(sampling_rate * st_step))\n posterior_matrix = []\n\n # for each feature vector (i.e. for each fix-sized segment):\n for col_index in range(mt_feats.shape[1]):\n # normalize current feature v\n feature_vector = (mt_feats[:, col_index] - mean) / std\n\n # classify vector:\n label_predicted, posterior = \\\n at.classifier_wrapper(classifier, model_type, feature_vector)\n labels.append(label_predicted)\n\n # update probability matrix\n posterior_matrix.append(np.max(posterior))\n labels = np.array(labels)\n\n # convert fix-sized flags to segments and classes\n segs, classes = labels_to_segments(labels, mid_step)\n segs[-1] = len(signal) / float(sampling_rate)\n # Load grount-truth:\n labels_gt, class_names_gt, accuracy, cm = \\\n load_ground_truth(gt_file, labels, class_names, mid_step, plot_results)\n\n return labels, class_names, accuracy, cm\n\n\ndef load_ground_truth(gt_file, labels, class_names, mid_step, plot_results):\n accuracy = 0\n cm = np.array([])\n labels_gt = np.array([])\n if os.path.isfile(gt_file):\n # load ground truth and class names\n labels_gt, class_names_gt = load_ground_truth_segments(gt_file,\n mid_step)\n # map predicted labels to ground truth class names\n # Note: if a predicted label does not belong to the ground truth\n # classes --> -1\n labels_new = []\n for il, l in enumerate(labels):\n if class_names[int(l)] in class_names_gt:\n labels_new.append(class_names_gt.index(class_names[int(l)]))\n else:\n labels_new.append(-1)\n labels_new = np.array(labels_new)\n cm = calculate_confusion_matrix(labels_new, labels_gt, class_names_gt)\n\n accuracy = plot_segmentation_results(labels_new, labels_gt,\n class_names, mid_step, not plot_results)\n if accuracy >= 0:\n print(\"Overall Accuracy: {0:.2f}\".format(accuracy))\n\n return labels_gt, class_names, accuracy, cm\n\n\ndef evaluate_segmentation_classification_dir(dir_name, model_name, method_name):\n\n accuracies = []\n class_names = []\n cm_total = np.array([])\n for index, wav_file in enumerate(glob.glob(dir_name + os.sep + '*.wav')):\n print(wav_file)\n\n gt_file = wav_file.replace('.wav', '.segments')\n\n if method_name.lower() in [\"svm\", \"svm_rbf\", \"knn\", \"randomforest\",\n \"gradientboosting\", \"extratrees\"]:\n flags_ind, class_names, accuracy, cm_temp = \\\n mid_term_file_classification(wav_file, model_name, method_name,\n False, gt_file)\n else:\n flags_ind, class_names, accuracy, cm_temp = \\\n hmm_segmentation(wav_file, model_name, False, gt_file)\n if accuracy > 0:\n if not index:\n cm_total = np.copy(cm_temp)\n else:\n cm_total = cm_total + cm_temp\n accuracies.append(accuracy)\n print(cm_temp, class_names)\n print(cm_total)\n\n if len(cm_total.shape) > 1:\n cm_total = cm_total / np.sum(cm_total)\n rec, pre, f1 = compute_metrics(cm_total, class_names)\n\n print(\" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \")\n print(\"Average Accuracy: {0:.1f}\".\n format(100.0*np.array(accuracies).mean()))\n print(\"Average recall: {0:.1f}\".format(100.0*np.array(rec).mean()))\n print(\"Average precision: {0:.1f}\".format(100.0*np.array(pre).mean()))\n print(\"Average f1: {0:.1f}\".format(100.0*np.array(f1).mean()))\n print(\"Median Accuracy: {0:.1f}\".\n format(100.0*np.median(np.array(accuracies))))\n print(\"Min Accuracy: {0:.1f}\".format(100.0*np.array(accuracies).min()))\n print(\"Max Accuracy: {0:.1f}\".format(100.0*np.array(accuracies).max()))\n else:\n print(\"Confusion matrix was empty, accuracy for every file was 0\")\n\n\ndef silence_removal(signal, sampling_rate, st_win, st_step, smooth_window=0.5,\n weight=0.5, plot=False):\n \"\"\"\n Event Detection (silence removal)\n ARGUMENTS:\n - signal: the input audio signal\n - sampling_rate: sampling freq\n - st_win, st_step: window size and step in seconds\n - smoothWindow: (optinal) smooth window (in seconds)\n - weight: (optinal) weight factor (0 < weight < 1)\n the higher, the more strict\n - plot: (optinal) True if results are to be plotted\n RETURNS:\n - seg_limits: list of segment limits in seconds (e.g [[0.1, 0.9],\n [1.4, 3.0]] means that\n the resulting segments are (0.1 - 0.9) seconds\n and (1.4, 3.0) seconds\n \"\"\"\n\n if weight >= 1:\n weight = 0.99\n if weight <= 0:\n weight = 0.01\n\n # Step 1: feature extraction\n signal = audioBasicIO.stereo_to_mono(signal)\n st_feats, _ = stf.feature_extraction(signal, sampling_rate,\n st_win * sampling_rate,\n st_step * sampling_rate)\n\n # Step 2: train binary svm classifier of low vs high energy frames\n # keep only the energy short-term sequence (2nd feature)\n st_energy = st_feats[1, :]\n en = np.sort(st_energy)\n # number of 10% of the total short-term windows\n st_windows_fraction = int(len(en) / 10)\n\n # compute \"lower\" 10% energy threshold\n low_threshold = np.mean(en[0:st_windows_fraction]) + 1e-15\n\n # compute \"higher\" 10% energy threshold\n high_threshold = np.mean(en[-st_windows_fraction:-1]) + 1e-15\n\n # get all features that correspond to low energy\n low_energy = st_feats[:, np.where(st_energy <= low_threshold)[0]]\n\n # get all features that correspond to high energy\n high_energy = st_feats[:, np.where(st_energy >= high_threshold)[0]]\n\n # form the binary classification task and ...\n features = [low_energy.T, high_energy.T]\n # normalize and train the respective svm probabilistic model\n\n # (ONSET vs SILENCE)\n features_norm, mean, std = at.normalize_features(features)\n svm = at.train_svm(features_norm, 1.0)\n\n # Step 3: compute onset probability based on the trained svm\n prob_on_set = []\n for index in range(st_feats.shape[1]):\n # for each frame\n cur_fv = (st_feats[:, index] - mean) / std\n # get svm probability (that it belongs to the ONSET class)\n prob_on_set.append(svm.predict_proba(cur_fv.reshape(1, -1))[0][1])\n prob_on_set = np.array(prob_on_set)\n\n # smooth probability:\n prob_on_set = smooth_moving_avg(prob_on_set, smooth_window / st_step)\n\n # Step 4A: detect onset frame indices:\n prog_on_set_sort = np.sort(prob_on_set)\n\n # find probability Threshold as a weighted average\n # of top 10% and lower 10% of the values\n nt = int(prog_on_set_sort.shape[0] / 10)\n threshold = (np.mean((1 - weight) * prog_on_set_sort[0:nt]) +\n weight * np.mean(prog_on_set_sort[-nt::]))\n\n max_indices = np.where(prob_on_set > threshold)[0]\n # get the indices of the frames that satisfy the thresholding\n index = 0\n seg_limits = []\n time_clusters = []\n\n # Step 4B: group frame indices to onset segments\n while index < len(max_indices):\n # for each of the detected onset indices\n cur_cluster = [max_indices[index]]\n if index == len(max_indices)-1:\n break\n while max_indices[index+1] - cur_cluster[-1] <= 2:\n cur_cluster.append(max_indices[index+1])\n index += 1\n if index == len(max_indices)-1:\n break\n index += 1\n time_clusters.append(cur_cluster)\n seg_limits.append([cur_cluster[0] * st_step,\n cur_cluster[-1] * st_step])\n\n # Step 5: Post process: remove very small segments:\n min_duration = 0.2\n seg_limits_2 = []\n for s_lim in seg_limits:\n if s_lim[1] - s_lim[0] > min_duration:\n seg_limits_2.append(s_lim)\n seg_limits = seg_limits_2\n\n if plot:\n time_x = np.arange(0, signal.shape[0] / float(sampling_rate), 1.0 /\n sampling_rate)\n\n plt.subplot(2, 1, 1)\n plt.plot(time_x, signal)\n for s_lim in seg_limits:\n plt.axvline(x=s_lim[0], color='red')\n plt.axvline(x=s_lim[1], color='red')\n plt.subplot(2, 1, 2)\n plt.plot(np.arange(0, prob_on_set.shape[0] * st_step, st_step), \n prob_on_set)\n plt.title('Signal')\n for s_lim in seg_limits:\n plt.axvline(x=s_lim[0], color='red')\n plt.axvline(x=s_lim[1], color='red')\n plt.title('svm Probability')\n plt.show()\n\n return seg_limits\n\n\ndef speaker_diarization(filename, n_speakers, mid_window=2.0, mid_step=0.2,\n short_window=0.05, lda_dim=35, plot_res=False):\n \"\"\"\n ARGUMENTS:\n - filename: the name of the WAV file to be analyzed\n - n_speakers the number of speakers (clusters) in\n the recording (<=0 for unknown)\n - mid_window (opt) mid-term window size\n - mid_step (opt) mid-term window step\n - short_window (opt) short-term window size\n - lda_dim (opt LDA dimension (0 for no LDA)\n - plot_res (opt) 0 for not plotting the results 1 for plotting\n \"\"\"\n sampling_rate, signal = audioBasicIO.read_audio_file(filename)\n signal = audioBasicIO.stereo_to_mono(signal)\n duration = len(signal) / sampling_rate\n\n base_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),\n \"data/models\")\n\n classifier_all, mean_all, std_all, class_names_all, _, _, _, _, _ = \\\n at.load_model_knn(os.path.join(base_dir, \"knn_speaker_10\"))\n classifier_fm, mean_fm, std_fm, class_names_fm, _, _, _, _, _ = \\\n at.load_model_knn(os.path.join(base_dir, \"knn_speaker_male_female\"))\n\n mid_feats, st_feats, _ = \\\n mtf.mid_feature_extraction(signal, sampling_rate,\n mid_window * sampling_rate,\n mid_step * sampling_rate,\n round(sampling_rate * short_window),\n round(sampling_rate * short_window * 0.5))\n\n mid_term_features = np.zeros((mid_feats.shape[0] + len(class_names_all) +\n len(class_names_fm), mid_feats.shape[1]))\n\n for index in range(mid_feats.shape[1]):\n feature_norm_all = (mid_feats[:, index] - mean_all) / std_all\n feature_norm_fm = (mid_feats[:, index] - mean_fm) / std_fm\n _, p1 = at.classifier_wrapper(classifier_all, \"knn\", feature_norm_all)\n _, p2 = at.classifier_wrapper(classifier_fm, \"knn\", feature_norm_fm)\n start = mid_feats.shape[0]\n end = mid_feats.shape[0] + len(class_names_all)\n mid_term_features[0:mid_feats.shape[0], index] = mid_feats[:, index]\n mid_term_features[start:end, index] = p1 + 1e-4\n mid_term_features[end::, index] = p2 + 1e-4\n\n mid_feats = mid_term_features # TODO\n feature_selected = [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 41,\n 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53]\n\n mid_feats = mid_feats[feature_selected, :]\n\n mid_feats_norm, mean, std = at.normalize_features([mid_feats.T])\n mid_feats_norm = mid_feats_norm[0].T\n n_wins = mid_feats.shape[1]\n\n # remove outliers:\n dist_all = np.sum(distance.squareform(distance.pdist(mid_feats_norm.T)),\n axis=0)\n m_dist_all = np.mean(dist_all)\n i_non_outliers = np.nonzero(dist_all < 1.2 * m_dist_all)[0]\n\n # TODO: Combine energy threshold for outlier removal:\n # EnergyMin = np.min(mt_feats[1,:])\n # EnergyMean = np.mean(mt_feats[1,:])\n # Thres = (1.5*EnergyMin + 0.5*EnergyMean) / 2.0\n # i_non_outliers = np.nonzero(mt_feats[1,:] > Thres)[0]\n # print i_non_outliers\n\n mt_feats_norm_or = mid_feats_norm\n mid_feats_norm = mid_feats_norm[:, i_non_outliers]\n\n # LDA dimensionality reduction:\n if lda_dim > 0:\n\n # extract mid-term features with minimum step:\n window_ratio = int(round(mid_window / short_window))\n step_ratio = int(round(short_window / short_window))\n mt_feats_to_red = []\n num_of_features = len(st_feats)\n num_of_stats = 2\n for index in range(num_of_stats * num_of_features):\n mt_feats_to_red.append([])\n\n # for each of the short-term features:\n for index in range(num_of_features):\n cur_pos = 0\n feat_len = len(st_feats[index])\n while cur_pos < feat_len:\n n1 = cur_pos\n n2 = cur_pos + window_ratio\n if n2 > feat_len:\n n2 = feat_len\n short_features = st_feats[index][n1:n2]\n mt_feats_to_red[index].append(np.mean(short_features))\n mt_feats_to_red[index + num_of_features].\\\n append(np.std(short_features))\n cur_pos += step_ratio\n mt_feats_to_red = np.array(mt_feats_to_red)\n mt_feats_to_red_2 = np.zeros((mt_feats_to_red.shape[0] +\n len(class_names_all) +\n len(class_names_fm),\n mt_feats_to_red.shape[1]))\n limit = mt_feats_to_red.shape[0] + len(class_names_all)\n for index in range(mt_feats_to_red.shape[1]):\n feature_norm_all = (mt_feats_to_red[:, index] - mean_all) / std_all\n feature_norm_fm = (mt_feats_to_red[:, index] - mean_fm) / std_fm\n _, p1 = at.classifier_wrapper(classifier_all, \"knn\",\n feature_norm_all)\n _, p2 = at.classifier_wrapper(classifier_fm, \"knn\", feature_norm_fm)\n mt_feats_to_red_2[0:mt_feats_to_red.shape[0], index] = \\\n mt_feats_to_red[:, index]\n mt_feats_to_red_2[mt_feats_to_red.shape[0]:limit, index] = p1 + 1e-4\n mt_feats_to_red_2[limit::, index] = p2 + 1e-4\n mt_feats_to_red = mt_feats_to_red_2\n mt_feats_to_red = mt_feats_to_red[feature_selected, :]\n mt_feats_to_red, mean, std = at.normalize_features([mt_feats_to_red.T])\n mt_feats_to_red = mt_feats_to_red[0].T\n labels = np.zeros((mt_feats_to_red.shape[1], ))\n lda_step = 1.0\n lda_step_ratio = lda_step / short_window\n for index in range(labels.shape[0]):\n labels[index] = int(index * short_window / lda_step_ratio)\n clf = sklearn.discriminant_analysis.\\\n LinearDiscriminantAnalysis(n_components=lda_dim)\n clf.fit(mt_feats_to_red.T, labels)\n mid_feats_norm = (clf.transform(mid_feats_norm.T)).T\n\n if n_speakers <= 0:\n s_range = range(2, 10)\n else:\n s_range = [n_speakers]\n cluster_labels = []\n sil_all = []\n cluster_centers = []\n \n for speakers in s_range:\n k_means = sklearn.cluster.KMeans(n_clusters=speakers)\n k_means.fit(mid_feats_norm.T)\n cls = k_means.labels_ \n means = k_means.cluster_centers_\n\n cluster_labels.append(cls)\n cluster_centers.append(means)\n sil_1, sil_2 = [], []\n for c in range(speakers):\n # for each speaker (i.e. for each extracted cluster)\n clust_per_cent = np.nonzero(cls == c)[0].shape[0] / float(len(cls))\n if clust_per_cent < 0.020:\n sil_1.append(0.0)\n sil_2.append(0.0)\n else:\n # get subset of feature vectors\n mt_feats_norm_temp = mid_feats_norm[:, cls == c]\n # compute average distance between samples\n # that belong to the cluster (a values)\n dist = distance.pdist(mt_feats_norm_temp.T)\n sil_1.append(np.mean(dist)*clust_per_cent)\n sil_temp = []\n for c2 in range(speakers):\n # compute distances from samples of other clusters\n if c2 != c:\n clust_per_cent_2 = np.nonzero(cls == c2)[0].shape[0] /\\\n float(len(cls))\n mid_features_temp = mid_feats_norm[:, cls == c2]\n dist = distance.cdist(mt_feats_norm_temp.T,\n mid_features_temp.T)\n sil_temp.append(np.mean(dist)*(clust_per_cent\n + clust_per_cent_2)/2.0)\n sil_temp = np.array(sil_temp)\n # ... and keep the minimum value (i.e.\n # the distance from the \"nearest\" cluster)\n sil_2.append(min(sil_temp))\n sil_1 = np.array(sil_1)\n sil_2 = np.array(sil_2)\n sil = []\n for c in range(speakers):\n # for each cluster (speaker) compute silhouette\n sil.append((sil_2[c] - sil_1[c]) / (max(sil_2[c], sil_1[c]) + 1e-5))\n # keep the AVERAGE SILLOUETTE\n sil_all.append(np.mean(sil))\n\n imax = int(np.argmax(sil_all))\n # optimal number of clusters\n num_speakers = s_range[imax]\n\n # generate the final set of cluster labels\n # (important: need to retrieve the outlier windows:\n # this is achieved by giving them the value of their\n # nearest non-outlier window)\n cls = np.zeros((n_wins,))\n for index in range(n_wins):\n j = np.argmin(np.abs(index-i_non_outliers))\n cls[index] = cluster_labels[imax][j]\n \n # Post-process method 1: hmm smoothing\n for index in range(1):\n # hmm training\n start_prob, transmat, means, cov = \\\n train_hmm_compute_statistics(mt_feats_norm_or, cls)\n hmm = hmmlearn.hmm.GaussianHMM(start_prob.shape[0], \"diag\")\n hmm.startprob_ = start_prob\n hmm.transmat_ = transmat \n hmm.means_ = means\n hmm.covars_ = cov\n cls = hmm.predict(mt_feats_norm_or.T) \n \n # Post-process method 2: median filtering:\n cls = scipy.signal.medfilt(cls, 13)\n cls = scipy.signal.medfilt(cls, 11)\n\n class_names = [\"speaker{0:d}\".format(c) for c in range(num_speakers)]\n\n # load ground-truth if available\n gt_file = filename.replace('.wav', '.segments')\n # if groundtruth exists\n if os.path.isfile(gt_file):\n seg_start, seg_end, seg_labs = read_segmentation_gt(gt_file)\n flags_gt, class_names_gt = segments_to_labels(seg_start, seg_end,\n seg_labs, mid_step)\n\n if plot_res:\n fig = plt.figure() \n if n_speakers > 0:\n ax1 = fig.add_subplot(111)\n else:\n ax1 = fig.add_subplot(211)\n ax1.set_yticks(np.array(range(len(class_names))))\n ax1.axis((0, duration, -1, len(class_names)))\n ax1.set_yticklabels(class_names)\n ax1.plot(np.array(range(len(cls))) * mid_step + mid_step / 2.0, cls)\n\n if os.path.isfile(gt_file):\n if plot_res:\n ax1.plot(np.array(range(len(flags_gt))) *\n mid_step + mid_step / 2.0, flags_gt, 'r')\n purity_cluster_m, purity_speaker_m = \\\n evaluate_speaker_diarization(cls, flags_gt)\n print(\"{0:.1f}\\t{1:.1f}\".format(100 * purity_cluster_m,\n 100 * purity_speaker_m))\n if plot_res:\n plt.title(\"Cluster purity: {0:.1f}% - \"\n \"Speaker purity: {1:.1f}%\".format(100 * purity_cluster_m,\n 100 * purity_speaker_m))\n if plot_res:\n plt.xlabel(\"time (seconds)\")\n if n_speakers <= 0:\n plt.subplot(212)\n plt.plot(s_range, sil_all)\n plt.xlabel(\"number of clusters\")\n plt.ylabel(\"average clustering's sillouette\")\n plt.show()\n return cls\n\n\ndef speaker_diarization_evaluation(folder_name, lda_dimensions):\n \"\"\"\n This function prints the cluster purity and speaker purity for\n each WAV file stored in a provided directory (.SEGMENT files\n are needed as ground-truth)\n ARGUMENTS:\n - folder_name: the full path of the folder where the WAV and\n segment (ground-truth) files are stored\n - lda_dimensions: a list of LDA dimensions (0 for no LDA)\n \"\"\"\n types = ('*.wav', )\n wav_files = []\n for files in types:\n wav_files.extend(glob.glob(os.path.join(folder_name, files)))\n \n wav_files = sorted(wav_files)\n\n # get number of unique speakers per file (from ground-truth) \n num_speakers = []\n for wav_file in wav_files:\n gt_file = wav_file.replace('.wav', '.segments')\n if os.path.isfile(gt_file):\n _, _, seg_labs = read_segmentation_gt(gt_file)\n num_speakers.append(len(list(set(seg_labs))))\n else:\n num_speakers.append(-1)\n \n for dim in lda_dimensions:\n print(\"LDA = {0:d}\".format(dim))\n for i, wav_file in enumerate(wav_files):\n speaker_diarization(wav_file, num_speakers[i], 2.0, 0.2, 0.05, dim,\n plot_res=False)\n\n\ndef music_thumbnailing(signal, sampling_rate, short_window=1.0, short_step=0.5,\n thumb_size=10.0, limit_1=0, limit_2=1):\n \"\"\"\n This function detects instances of the most representative part of a\n music recording, also called \"music thumbnails\".\n A technique similar to the one proposed in [1], however a wider set of\n audio features is used instead of chroma features.\n In particular the following steps are followed:\n - Extract short-term audio features. Typical short-term window size: 1\n second\n - Compute the self-similarity matrix, i.e. all pairwise similarities\n between feature vectors\n - Apply a diagonal mask is as a moving average filter on the values of the\n self-similarty matrix.\n The size of the mask is equal to the desirable thumbnail length.\n - Find the position of the maximum value of the new (filtered)\n self-similarity matrix. The audio segments that correspond to the\n diagonial around that position are the selected thumbnails\n \n\n ARGUMENTS:\n - signal: input signal\n - sampling_rate: sampling frequency\n - short_window: window size (in seconds)\n - short_step: window step (in seconds)\n - thumb_size: desider thumbnail size (in seconds)\n \n RETURNS:\n - A1: beginning of 1st thumbnail (in seconds)\n - A2: ending of 1st thumbnail (in seconds)\n - B1: beginning of 2nd thumbnail (in seconds)\n - B2: ending of 2nd thumbnail (in seconds)\n\n USAGE EXAMPLE:\n import audioFeatureExtraction as aF\n [fs, x] = basicIO.readAudioFile(input_file)\n [A1, A2, B1, B2] = musicThumbnailing(x, fs)\n\n [1] Bartsch, M. A., & Wakefield, G. H. (2005). Audio thumbnailing\n of popular music using chroma-based representations.\n Multimedia, IEEE Transactions on, 7(1), 96-104.\n \"\"\"\n signal = audioBasicIO.stereo_to_mono(signal)\n # feature extraction:\n st_feats, _ = stf.feature_extraction(signal, sampling_rate,\n sampling_rate * short_window,\n sampling_rate * short_step)\n\n # self-similarity matrix\n sim_matrix = self_similarity_matrix(st_feats)\n\n # moving filter:\n m_filter = int(round(thumb_size / short_step))\n diagonal = np.eye(m_filter, m_filter)\n sim_matrix = scipy.signal.convolve2d(sim_matrix, diagonal, 'valid')\n\n # post-processing (remove main diagonal elements)\n min_sm = np.min(sim_matrix)\n for i in range(sim_matrix.shape[0]):\n for j in range(sim_matrix.shape[1]):\n if abs(i-j) < 5.0 / short_step or i > j:\n sim_matrix[i, j] = min_sm\n\n # find max position:\n sim_matrix[0:int(limit_1 * sim_matrix.shape[0]), :] = min_sm\n sim_matrix[:, 0:int(limit_1 * sim_matrix.shape[0])] = min_sm\n sim_matrix[int(limit_2 * sim_matrix.shape[0])::, :] = min_sm\n sim_matrix[:, int(limit_2 * sim_matrix.shape[0])::] = min_sm\n\n rows, cols = np.unravel_index(sim_matrix.argmax(), sim_matrix.shape)\n i1 = rows\n i2 = rows\n j1 = cols\n j2 = cols\n\n while i2-i1 < m_filter:\n if i1 <= 0 or j1 <= 0 or i2 >= sim_matrix.shape[0]-2 or \\\n j2 >= sim_matrix.shape[1]-2:\n break\n if sim_matrix[i1-1, j1-1] > sim_matrix[i2 + 1, j2 + 1]:\n i1 -= 1\n j1 -= 1 \n else: \n i2 += 1\n j2 += 1 \n\n return short_step * i1, short_step * i2, short_step * j1, short_step * j2, \\\n sim_matrix\n\n\n\n"
] | [
[
"numpy.copy",
"numpy.min",
"numpy.mean",
"numpy.where",
"numpy.sort",
"numpy.unique",
"numpy.max",
"numpy.concatenate",
"numpy.count_nonzero",
"numpy.nonzero",
"numpy.eye",
"scipy.signal.medfilt",
"numpy.argmax",
"numpy.arange",
"matplotlib.pyplot.subplot",
"sklearn.discriminant_analysis.LinearDiscriminantAnalysis",
"numpy.array",
"numpy.zeros",
"matplotlib.pyplot.title",
"matplotlib.pyplot.rc",
"matplotlib.pyplot.figure",
"numpy.std",
"matplotlib.pyplot.show",
"matplotlib.pyplot.axvline",
"scipy.spatial.distance.cdist",
"scipy.spatial.distance.pdist",
"numpy.sum",
"matplotlib.pyplot.xlabel",
"numpy.ones",
"matplotlib.pyplot.plot",
"sklearn.cluster.KMeans",
"numpy.abs",
"matplotlib.pyplot.ylabel",
"scipy.signal.convolve2d"
]
] |
BwCai/DCAA-UDA | [
"359c2122060aebfbe4384c918768c261fe2dc9c7"
] | [
"models/adaptation_model_stage1.py"
] | [
"from models.base_model import BaseModel\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport os, sys\nimport torch\nimport numpy as np\nimport itertools\n\nfrom torch.autograd import Variable\nfrom optimizers import get_optimizer\nfrom schedulers import get_scheduler\nfrom models.sync_batchnorm import SynchronizedBatchNorm2d, DataParallelWithCallback\nfrom models.deeplab_multimodal import DeepLab\nfrom models.decoder import Decoder\nfrom models.aspp import ASPP\nfrom models.discriminator import FCDiscriminator, FCDiscriminator_low, FCDiscriminator_out, FCDiscriminator_class\nfrom loss import get_loss_function\nfrom .utils import freeze_bn, GradReverse, normalisation_pooling\nfrom metrics import runningScore\nimport pdb\n\ndef multimodal_merger(multi_modal_data, is_upsample=False, up_size=None):\n \"\"\"\n [Func Handler] multimodal_merger:\n @Input Params:\n multi_modal_data: dict.\n examples: {\n \"feat_cls\": feat_cls,\n \"output\": output,\n }\n @Reture:\n merge_out: dict.\n examples: {\n \"feat_cls\": feat_cls,\n \"output_comb\": output_comb,\n \"output\": output,\n }\n \"\"\"\n feat_cls = multi_modal_data['feat_cls']\n # merge class features\n feat_cls_cat = torch.cat(feat_cls, 1) # concat \n # merge output pred\n output = multi_modal_data['output']\n output_comb = 0\n for _i in range(len(output)):\n if is_upsample:\n output[_i] = F.interpolate(output[_i], size=up_size, mode='bilinear', align_corners=True)\n output_comb += output[_i]\n\n merge_out = {\n 'feat_cls': feat_cls,\n 'feat_cls_cat': feat_cls_cat,\n 'output_comb': output_comb,\n 'output': output,\n }\n return merge_out\n\nclass CustomMetricsMultimodalMerger():\n \"\"\"\n [Func Handler] objective_vectors_multimodal_merger:\n @Input Params:\n multi_modal_data: dict.\n examples: {\n \"class_threshold_group\": [model.class_threshold_group[modal_idx][i], ...]\n \"objective_vectors_group\": [model.objective_vectors_group[modal_idx][i], ...],\n }\n cate_idx: int. 0 ~ 18\n modal_ids: list.\n examples: [0, 1] or [0,]\n @Reture:\n merge_out: dict.\n examples: {\n \"class_threshold\": class_threshold,\n \"objective_vectors\": objective_vectors,\n }\n \"\"\"\n\n def __init__(self, modal_num, category_num, model):\n self.modal_num = modal_num\n self.category_num = category_num\n self._model = model\n\n def initialize_model(model):\n self._model = model\n\n def merge_class_threshold(self, modal_ids=[]):\n assert self._model is not None, \"[ERROR] Deeplab Model not initialize before using!\"\n _class_threshold_group = self._model.class_threshold_group[modal_ids]\n return torch.mean(_class_threshold_group, dim=0) # modal_num x 19 --> 19\n\n def merge_clu_threshold(self, clu_threshold, modal_ids=[]):\n _clu_threshold_group = clu_threshold[modal_ids]\n return torch.mean(_clu_threshold_group, dim=0)\n\n def merge_objective_vectors(self, modal_ids=[]):\n assert self._model is not None, \"[ERROR] Deeplab Model not initialize before using!\"\n _modal_num, _cate_num, _feat_dim = self._model.objective_vectors_group.size()\n _objective_vectors = self._model.objective_vectors_group[modal_ids]\n # modal_num x 19 x 256 --> 19 x modal_num x 256 --> 19 x (modal_num x 256)\n assert _objective_vectors.dim() == 4, \"objective_vector dimension != 4\"\n _objective_vectors = _objective_vectors.permute(1, 0, 2).contiguous()\n\n return _objective_vectors.view(_cate_num, -1)\n\nclass CustomMetrics():\n def __init__(self, numbers=19, modal_num=3, model=None):\n self.class_numbers = numbers\n self.classes_recall_thr = np.zeros([19, 3])\n self.classes_recall_thr_num = np.zeros([19])\n self.classes_recall_clu = np.zeros([19, 3])\n self.classes_recall_clu_num = np.zeros([19])\n self.running_metrics_val_threshold = runningScore(self.class_numbers)\n self.running_metrics_val_clusters = runningScore(self.class_numbers)\n self.clu_threshold = torch.full((modal_num + 1, 19), 2.5).cuda()\n self.multimodal_merger = CustomMetricsMultimodalMerger(\n modal_num=modal_num + 1, category_num=numbers, model=model\n )\n \n def update(self, feat_cls, outputs, labels, modal_ids=[0,]): \n '''calculate accuracy. caring about recall but not IoU'''\n batch, width, height = labels.shape\n labels = labels.reshape([batch, 1, width, height]).float()\n labels = F.interpolate(labels, size=feat_cls.size()[2:], mode='nearest')\n outputs_threshold = outputs.clone()\n outputs_threshold = F.softmax(outputs_threshold, dim=1)\n #self.running_metrics_val_threshold.update(labels.cpu().numpy(), outputs_threshold.argmax(1).cpu().numpy())\n self.running_metrics_val_threshold.update(labels, outputs_threshold.argmax(1))\n\n _class_threshold_set = self.multimodal_merger.merge_class_threshold(modal_ids=modal_idx)\n for i in range(19):\n outputs_threshold[:, i, :, :] = torch.where(outputs_threshold[:, i, :, :] > _class_threshold_set[i], torch.Tensor([1]).cuda(), torch.Tensor([0]).cuda())\n\n _batch, _channel, _w, _h = outputs_threshold.shape\n _tmp = torch.full([_batch, 1, _w, _h], 0.2,).cuda()\n _tmp = torch.cat((outputs_threshold, _tmp), 1)\n threshold_arg = _tmp.argmax(1, keepdim=True)\n threshold_arg[threshold_arg == 19] = 250 #ignore index\n truth, pred_all, truth_all = self.calc_recall(labels.cpu().int().numpy(), threshold_arg.cpu().int().numpy())\n self.classes_recall_thr[:, 0] += truth\n self.classes_recall_thr[:, 2] += pred_all\n self.classes_recall_thr[:, 1] += truth_all\n\n outputs_cluster = outputs.clone()\n _objective_vectors_set = self.multimodal_merger.merge_objective_vectors(modal_ids=modal_idx)\n\n for i in range(19):\n outputs_cluster[:, i, :, :] = torch.norm( _objective_vectors_set[i].reshape(-1,1,1).expand(-1,128,256) - feat_cls, 2, dim=1,)\n\n outputs_cluster_min, outputs_cluster_arg = outputs_cluster.min(dim=1, keepdim=True)\n outputs_cluster_second = outputs_cluster.scatter_(1, outputs_cluster_arg, 100)\n if torch.unique(outputs_cluster_second.argmax(1) - outputs_cluster_arg.squeeze()).squeeze().item() != 0:\n raise NotImplementedError('wrong when computing L2 norm!!')\n outputs_cluster_secondmin, outputs_cluster_secondarg = outputs_cluster_second.min(dim=1, keepdim=True)\n #self.running_metrics_val_clusters.update(labels.cpu().numpy(), outputs_cluster_arg.cpu().numpy())\n self.running_metrics_val_clusters.update(labels, outputs_cluster_arg)\n \n tmp_arg = outputs_cluster_arg.clone()\n pdb.set_trace()\n _clu_thresholds = self.multimodal_merger.merge_clu_threshold(self.clu_threshold, modal_ids=modal_ids)\n\n outputs_cluster_arg[(outputs_cluster_secondmin - outputs_cluster_min) < _clu_thresholds] = 250\n truth, pred_all, truth_all = self.calc_recall(labels.cpu().int().numpy(), outputs_cluster_arg.cpu().int().numpy())\n self.classes_recall_clu[:, 0] += truth\n self.classes_recall_clu[:, 2] += pred_all\n self.classes_recall_clu[:, 1] += truth_all\n return threshold_arg, outputs_cluster_arg\n\n def calc_recall(self, gt, argmax):\n truth = np.zeros([self.class_numbers])\n pred_all = np.zeros([self.class_numbers])\n truth_all = np.zeros([self.class_numbers])\n for i in range(self.class_numbers):\n truth[i] = (gt == i)[argmax == i].sum()\n pred_all[i] = (argmax == i).sum()\n truth_all[i] = (gt == i).sum()\n pass\n return truth, pred_all, truth_all\n \n def calc_mean_Clu_recall(self, ):\n return np.mean(self.classes_recall_clu[:, 0] / self.classes_recall_clu[:, 1])\n \n def calc_mean_Thr_recall(self, ):\n return np.mean(self.classes_recall_thr[:, 0] / self.classes_recall_thr[:, 1])\n\n def reset(self, ):\n self.running_metrics_val_clusters.reset()\n self.running_metrics_val_threshold.reset()\n self.classes_recall_clu = np.zeros([19, 3])\n self.classes_recall_thr = np.zeros([19, 3])\n\nclass CustomModel():\n def __init__(self, cfg, writer, logger, use_pseudo_label=False, modal_num=3):\n self.cfg = cfg\n self.writer = writer\n self.class_numbers = 19\n self.logger = logger\n cfg_model = cfg['model']\n self.cfg_model = cfg_model\n self.best_iou = -100\n self.iter = 0\n self.nets = []\n self.split_gpu = 0\n self.default_gpu = cfg['model']['default_gpu']\n self.PredNet_Dir = None\n self.valid_classes = cfg['training']['valid_classes']\n self.G_train = True\n self.cls_feature_weight = cfg['training']['cls_feature_weight']\n self.use_pseudo_label = use_pseudo_label\n self.modal_num = modal_num\n\n # cluster vectors & cuda initialization\n self.objective_vectors_group = torch.zeros(self.modal_num + 1, 19, 256).cuda()\n self.objective_vectors_num_group = torch.zeros(self.modal_num + 1, 19).cuda()\n self.objective_vectors_dis_group = torch.zeros(self.modal_num + 1, 19, 19).cuda()\n self.class_threshold_group = torch.full([self.modal_num + 1, 19], 0.95).cuda()\n\n #self.metrics = CustomMetrics(self.class_numbers)\n self.metrics = CustomMetrics(self.class_numbers, modal_num=self.modal_num, model=self)\n\n bn = cfg_model['bn']\n if bn == 'sync_bn':\n BatchNorm = SynchronizedBatchNorm2d\n elif bn == 'bn':\n BatchNorm = nn.BatchNorm2d\n elif bn == 'gn':\n BatchNorm = nn.GroupNorm\n else:\n raise NotImplementedError('batch norm choice {} is not implemented'.format(bn))\n if use_pseudo_label:\n self.PredNet = DeepLab(\n num_classes=19,\n backbone=cfg_model['basenet']['version'],\n output_stride=16,\n bn=cfg_model['bn'],\n freeze_bn=True,\n modal_num=self.modal_num\n ).cuda()\n self.load_PredNet(cfg, writer, logger, dir=None, net=self.PredNet)\n self.PredNet_DP = self.init_device(self.PredNet, gpu_id=self.default_gpu, whether_DP=True) \n self.PredNet.eval()\n self.PredNet_num = 0\n\n self.BaseNet = DeepLab(\n num_classes=19,\n backbone=cfg_model['basenet']['version'],\n output_stride=16,\n bn=cfg_model['bn'],\n freeze_bn=True,\n modal_num=self.modal_num\n )\n\n logger.info('the backbone is {}'.format(cfg_model['basenet']['version']))\n\n self.BaseNet_DP = self.init_device(self.BaseNet, gpu_id=self.default_gpu, whether_DP=True)\n self.nets.extend([self.BaseNet])\n self.nets_DP = [self.BaseNet_DP]\n\n # Discriminator\n self.SOURCE_LABEL = 0\n self.TARGET_LABEL = 1\n self.DNets = []\n self.DNets_DP = []\n for _ in range(self.modal_num+1):\n _net_d = FCDiscriminator(inplanes=19)\n self.DNets.append(_net_d)\n _net_d_DP = self.init_device(_net_d, gpu_id=self.default_gpu, whether_DP=True)\n self.DNets_DP.append(_net_d_DP)\n\n self.nets.extend(self.DNets)\n self.nets_DP.extend(self.DNets_DP)\n\n self.optimizers = []\n self.schedulers = [] \n optimizer_cls = torch.optim.SGD\n optimizer_params = {k:v for k, v in cfg['training']['optimizer'].items() \n if k != 'name'}\n\n optimizer_cls_D = torch.optim.Adam\n optimizer_params_D = {k:v for k, v in cfg['training']['optimizer_D'].items() \n if k != 'name'}\n\n if self.use_pseudo_label:\n self.BaseOpti = optimizer_cls(self.BaseNet.parameters(), **optimizer_params)\n else:\n self.BaseOpti = optimizer_cls(self.BaseNet.optim_parameters(cfg['training']['optimizer']['lr']), **optimizer_params)\n self.optimizers.extend([self.BaseOpti])\n\n self.DiscOptis = []\n for _d_net in self.DNets: \n self.DiscOptis.append(\n optimizer_cls_D(_d_net.parameters(), **optimizer_params_D)\n )\n self.optimizers.extend(self.DiscOptis)\n\n self.schedulers = [] \n if self.use_pseudo_label:\n self.BaseSchedule = get_scheduler(self.BaseOpti, cfg['training']['lr_schedule'])\n self.schedulers.extend([self.BaseSchedule])\n else:\n \"\"\"BaseSchedule detail see FUNC: scheduler_step()\"\"\"\n self.learning_rate = cfg['training']['optimizer']['lr']\n self.gamma = cfg['training']['lr_schedule']['gamma']\n self.num_steps = cfg['training']['lr_schedule']['max_iter']\n self._BaseSchedule_nouse = get_scheduler(self.BaseOpti, cfg['training']['lr_schedule'])\n self.schedulers.extend([self._BaseSchedule_nouse])\n\n self.DiscSchedules = []\n for _disc_opt in self.DiscOptis:\n self.DiscSchedules.append(\n get_scheduler(_disc_opt, cfg['training']['lr_schedule'])\n )\n self.schedulers.extend(self.DiscSchedules)\n\n self.setup(cfg, writer, logger)\n\n self.adv_source_label = 0\n self.adv_target_label = 1\n self.bceloss = nn.BCEWithLogitsLoss(reduce=False)\n self.loss_fn = get_loss_function(cfg)\n self.mseloss = nn.MSELoss()\n self.l1loss = nn.L1Loss()\n self.smoothloss = nn.SmoothL1Loss()\n self.triplet_loss = nn.TripletMarginLoss()\n\n def create_PredNet(self,):\n ss = DeepLab(\n num_classes=19,\n backbone=self.cfg_model['basenet']['version'],\n output_stride=16,\n bn=self.cfg_model['bn'],\n freeze_bn=True,\n modal_num=self.modal_num,\n ).cuda()\n ss.eval()\n return ss\n\n def setup(self, cfg, writer, logger):\n '''\n set optimizer and load pretrained model\n '''\n for net in self.nets:\n # name = net.__class__.__name__\n self.init_weights(cfg['model']['init'], logger, net)\n print(\"Initializition completed\")\n if hasattr(net, '_load_pretrained_model') and cfg['model']['pretrained']:\n print(\"loading pretrained model for {}\".format(net.__class__.__name__))\n net._load_pretrained_model()\n '''load pretrained model\n '''\n if cfg['training']['resume_flag']:\n self.load_nets(cfg, writer, logger)\n pass\n\n def lr_poly(self):\n return self.learning_rate * ((1 - float(self.iter) / self.num_steps) ** (self.gamma))\n\n def adjust_basenet_learning_rate(self):\n lr = self.lr_poly()\n self.BaseOpti.param_groups[0]['lr'] = lr\n if len(self.BaseOpti.param_groups) > 1:\n self.BaseOpti.param_groups[1]['lr'] = lr * 10\n\n def forward(self, input):\n feat, feat_low, att_mask, feat_cls, output = self.BaseNet_DP(input)\n\n return feat, feat_low, feat_cls, output\n\n def forward_Up(self, input):\n feat, feat_low, feat_cls, outputs = self.forward(input)\n output = F.interpolate(outputs[-1], size=input.size()[2:], mode='bilinear', align_corners=True)\n return feat, feat_low, feat_cls, output\n\n def PredNet_Forward(self, input):\n with torch.no_grad():\n _, _, att_mask, feat_cls, output_result = self.PredNet_DP(input)\n return _, _, feat_cls, output_result\n\n def calculate_mean_vector(self, feat_cls, outputs, labels, ):\n outputs_softmax = F.softmax(outputs, dim=1)\n outputs_argmax = outputs_softmax.argmax(dim=1, keepdim=True)\n outputs_argmax = self.process_label(outputs_argmax.float())\n labels_expanded = self.process_label(labels)\n outputs_pred = labels_expanded * outputs_argmax\n scale_factor = F.adaptive_avg_pool2d(outputs_pred, 1)\n vectors = []\n ids = []\n for n in range(feat_cls.size()[0]):\n for t in range(self.class_numbers):\n if scale_factor[n][t].item()==0:\n continue\n if (outputs_pred[n][t] > 0).sum() < 10:\n continue\n s = feat_cls[n] * outputs_pred[n][t]\n scale = torch.sum(outputs_pred[n][t]) / labels.shape[2] / labels.shape[3] * 2\n s = normalisation_pooling()(s, scale)\n s = F.adaptive_avg_pool2d(s, 1) / scale_factor[n][t]\n vectors.append(s)\n ids.append(t)\n return vectors, ids\n\n def step(self, source_x, source_label, source_modal_ids, target_x, target_label, target_modal_ids, use_pseudo_loss=False):\n assert len(source_modal_ids) == source_x.size(0), \"modal_ids' batchsize != source_x's batchsize\"\n _, _, source_feat_cls, source_output = self.forward(input=source_x) \n\n \"\"\"source_output: [B x 19 x W x H, ...]\n select modal-branch output in each batchsize\n Specific-modal output\n \"\"\"\n source_output_modal_k = torch.stack(\n [\n source_output[_modal_i][_batch_i]\n for _batch_i, _modal_i in enumerate(source_modal_ids)\n ], \n dim=0,\n )\n # attention output & specific-modal output\n source_output_comb = torch.cat([source_output_modal_k, source_output[-1]], dim=0)\n\n source_label_comb = torch.cat([source_label, source_label.clone()], dim=0)\n\n source_outputUp = F.interpolate(source_output_comb, size=source_x.size()[-2:], mode='bilinear', align_corners=True)\n\n loss_GTA = self.loss_fn(input=source_outputUp, target=source_label_comb)\n #self.PredNet.eval()\n\n # adversarial loss\n # -----------------------------\n \"\"\"Generator (segmentation)\"\"\"\n # -----------------------------\n # On Source Domain \n loss_adv = torch.Tensor([0]).cuda()\n _batch_size = 0\n \n _, _, _, target_output = self.forward(target_x)\n\n target_modal_ids_tensor = torch.Tensor(target_modal_ids).cuda()\n for t_out, _d_net_DP, _d_net, modal_idx in zip(target_output, self.DNets_DP, self.DNets, range(len(target_output))):\n # set grad false\n self.set_requires_grad(self.logger, _d_net, requires_grad = False)\n # true/false discriminator\n t_D_out = _d_net_DP(F.softmax(t_out))\n #source_modal_ids\n loss_temp = torch.mean(self.bceloss(\n t_D_out,\n torch.FloatTensor(t_D_out.data.size()).fill_(1.0).cuda()\n ), [1,2,3])\n\n if modal_idx >= self.modal_num:\n loss_adv += torch.mean(loss_temp)\n elif torch.mean(torch.as_tensor((modal_idx==target_modal_ids_tensor), dtype=torch.float32)) == 0:\n loss_adv += 0.0\n else:\n loss_adv += torch.mean(torch.masked_select(loss_temp, target_modal_ids_tensor==modal_idx))\n\n _batch_size += t_out.size(0)\n\n #loss_adv /= _batch_size\n loss_adv *= self.cfg['training']['loss_adv_lambda']\n\n loss_G = torch.Tensor([0]).cuda()\n loss_G = loss_G + loss_GTA + loss_adv\n\n self.BaseOpti.zero_grad()\n if loss_G.item() != 0:\n loss_G.backward()\n self.BaseOpti.step()\n\n # -----------------------------\n \"\"\"Discriminator \"\"\"\n # -----------------------------\n \n _batch_size = 0\n loss_D_comb = torch.Tensor([0]).cuda()\n source_modal_ids_tensor = torch.Tensor(source_modal_ids).cuda()\n for s_out, t_out, _d_net_DP, _d_net, _disc_opt, modal_idx in zip(source_output, target_output, self.DNets_DP, self.DNets, self.DiscOptis, range(len(source_output))):\n self.set_requires_grad(self.logger, _d_net, requires_grad = True)\n\n _batch_size = 0\n loss_D = torch.Tensor([0]).cuda()\n # source domain\n s_D_out = _d_net_DP(F.softmax(s_out.detach()))\n\n loss_temp_s = torch.mean(self.bceloss(\n s_D_out,\n torch.FloatTensor(s_D_out.data.size()).fill_(1.0).cuda()\n ), [1,2,3])\n\n if modal_idx >= self.modal_num:\n loss_D += torch.mean(loss_temp_s)\n elif torch.mean(torch.as_tensor((modal_idx==source_modal_ids_tensor), dtype=torch.float32)) == 0:\n loss_D += 0.0\n else:\n loss_D += torch.mean(torch.masked_select(loss_temp_s, source_modal_ids_tensor==modal_idx))\n\n # target domain\n _batch_size += (s_out.size(0) + t_out.size(0))\n \n t_D_out = _d_net_DP(F.softmax(t_out.detach()))\n loss_temp_t = torch.mean(self.bceloss(\n t_D_out,\n torch.FloatTensor(t_D_out.data.size()).fill_(0.0).cuda()\n ), [1,2,3])\n\n if modal_idx >= self.modal_num:\n loss_D += torch.mean(loss_temp_t)\n elif torch.mean(torch.as_tensor((modal_idx==target_modal_ids_tensor), dtype=torch.float32)) == 0:\n loss_D += 0.0\n else:\n loss_D += torch.mean(torch.masked_select(loss_temp_t, target_modal_ids_tensor==modal_idx))\n\n loss_D *= self.cfg['training']['loss_adv_lambda']*0.5\n\n loss_D_comb += loss_D\n \n _disc_opt.zero_grad()\n if loss_D_comb.item() != 0:\n loss_D_comb.backward()\n _disc_opt.step()\n\n return loss_GTA, loss_adv, loss_D_comb\n\n\n def process_label(self, label):\n batch, channel, w, h = label.size()\n pred1 = torch.zeros(batch, 20, w, h).cuda()\n id = torch.where(label < 19, label, torch.Tensor([19]).cuda())\n pred1 = pred1.scatter_(1, id.long(), 1)\n return pred1\n\n def class_vectors_alignment(self, ids, vectors, modal_ids=[0,]):\n #loss = torch.Tensor([0]).cuda(self.default_gpu)\n loss = torch.Tensor([0]).cuda()\n\n \"\"\"construct category objective vectors\"\"\"\n # objective_vectors_group 2 x 19 x 256 --> 19 x 512\n _objective_vectors_set = self.metrics.multimodal_merger.merge_objective_vectors(modal_ids=modal_idx)\n\n for i in range(len(ids)):\n if ids[i] not in self.valid_classes:\n continue\n new_loss = self.smoothloss(vectors[i].squeeze().cuda(), _objective_vectors[ids[i]])\n while (new_loss.item() > 5):\n new_loss = new_loss / 10\n loss = loss + new_loss\n loss = loss / len(ids) * 10\n return loss\n\n def freeze_bn_apply(self):\n for net in self.nets:\n net.apply(freeze_bn)\n for net in self.nets_DP:\n net.apply(freeze_bn)\n\n def scheduler_step(self):\n if self.use_pseudo_label:\n for scheduler in self.schedulers:\n scheduler.step()\n else:\n \"\"\"skipped _BaseScheduler_nouse\"\"\"\n for scheduler in self.schedulers[1:]:\n scheduler.step()\n # baseNet scheduler\n self.adjust_basenet_learning_rate()\n \n def optimizer_zerograd(self):\n for optimizer in self.optimizers:\n optimizer.zero_grad()\n \n def optimizer_step(self):\n for opt in self.optimizers:\n opt.step()\n\n def init_device(self, net, gpu_id=None, whether_DP=False):\n gpu_id = gpu_id or self.default_gpu\n device = torch.device(\"cuda:{}\".format(gpu_id) if torch.cuda.is_available() else 'cpu')\n net = net.to(device)\n # if torch.cuda.is_available():\n if whether_DP:\n net = DataParallelWithCallback(net, device_ids=range(torch.cuda.device_count()))\n return net\n \n def eval(self, net=None, logger=None):\n \"\"\"Make specific models eval mode during test time\"\"\"\n if net == None:\n for net in self.nets:\n net.eval()\n for net in self.nets_DP:\n net.eval()\n if logger!=None: \n logger.info(\"Successfully set the model eval mode\") \n else:\n net.eval()\n if logger!=None: \n logger(\"Successfully set {} eval mode\".format(net.__class__.__name__))\n return\n\n def train(self, net=None, logger=None):\n if net==None:\n for net in self.nets:\n net.train()\n for net in self.nets_DP:\n net.train()\n else:\n net.train()\n return\n\n def set_requires_grad(self, logger, net, requires_grad = False):\n \"\"\"Set requires_grad=Fasle for all the networks to avoid unnecessary computations\n Parameters:\n net (BaseModel) -- the network which will be operated on\n requires_grad (bool) -- whether the networks require gradients or not\n \"\"\"\n for parameter in net.parameters():\n parameter.requires_grad = requires_grad\n \n def set_requires_grad_layer(self, logger, net, layer_type='batchnorm', requires_grad=False): \n ''' set specific type of layers whether needing grad\n '''\n\n # print('Warning: all the BatchNorm params are fixed!')\n # logger.info('Warning: all the BatchNorm params are fixed!')\n for net in self.nets:\n for _i in net.modules():\n if _i.__class__.__name__.lower().find(layer_type.lower()) != -1:\n _i.weight.requires_grad = requires_grad\n return\n\n def init_weights(self, cfg, logger, net, init_type='normal', init_gain=0.02):\n \"\"\"Initialize network weights.\n\n Parameters:\n net (network) -- network to be initialized\n init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal\n init_gain (float) -- scaling factor for normal, xavier and orthogonal.\n\n We use 'normal' in the original pix2pix and CycleGAN paper. But xavier and kaiming might\n work better for some applications. Feel free to try yourself.\n \"\"\"\n init_type = cfg.get('init_type', init_type)\n init_gain = cfg.get('init_gain', init_gain)\n def init_func(m): # define the initialization function\n classname = m.__class__.__name__\n if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):\n if init_type == 'normal':\n nn.init.normal_(m.weight.data, 0.0, init_gain)\n elif init_type == 'xavier':\n nn.init.xavier_normal_(m.weight.data, gain=init_gain)\n elif init_type == 'kaiming':\n nn.init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')\n elif init_type == 'orthogonal':\n nn.init.orthogonal_(m.weight.data, gain=init_gain)\n else:\n raise NotImplementedError('initialization method [%s] is not implemented' % init_type)\n if hasattr(m, 'bias') and m.bias is not None:\n nn.init.constant_(m.bias.data, 0.0)\n elif isinstance(m, SynchronizedBatchNorm2d) or classname.find('BatchNorm2d') != -1 \\\n or isinstance(m, nn.GroupNorm):\n m.weight.data.fill_(1)\n m.bias.data.zero_() # BatchNorm Layer's weight is not a matrix; only normal distribution applies.\n\n\n print('initialize {} with {}'.format(init_type, net.__class__.__name__))\n logger.info('initialize {} with {}'.format(init_type, net.__class__.__name__))\n net.apply(init_func) # apply the initialization function <init_func>\n pass\n\n def adaptive_load_nets(self, net, model_weight):\n model_dict = net.state_dict()\n pretrained_dict = {k : v for k, v in model_weight.items() if k in model_dict}\n \n # print(\"[INFO] Pretrained dict:\", pretrained_dict.keys())\n model_dict.update(pretrained_dict)\n net.load_state_dict(model_dict)\n\n def load_nets(self, cfg, writer, logger): # load pretrained weights on the net\n if os.path.isfile(cfg['training']['resume']):\n logger.info(\n \"Loading model and optimizer from checkpoint '{}'\".format(cfg['training']['resume'])\n )\n checkpoint = torch.load(cfg['training']['resume'])\n _k = -1\n net_state_no = {}\n for net in self.nets:\n name = net.__class__.__name__\n if name not in net_state_no:\n net_state_no[name] = 0\n else:\n net_state_no[name] += 1\n _k += 1\n if checkpoint.get(name) == None:\n continue\n if name.find('FCDiscriminator') != -1 and cfg['training']['gan_resume'] == False:\n continue\n if isinstance(checkpoint[name], list):\n self.adaptive_load_nets(net, checkpoint[name][net_state_no[name]][\"model_state\"])\n else:\n print(\"*****************************************\")\n print(\"[WARNING] Using depreciated load version! Model {}\".format(name))\n print(\"*****************************************\")\n self.adaptive_load_nets(net, checkpoint[name][\"model_state\"])\n if cfg['training']['optimizer_resume']:\n if isinstance(checkpoint[name], list):\n self.adaptive_load_nets(self.optimizers[_k], checkpoint[name][net_state_no[name]][\"optimizer_state\"])\n self.adaptive_load_nets(self.schedulers[_k], checkpoint[name][net_state_no[name]][\"scheduler_state\"])\n else:\n self.adaptive_load_nets(self.optimizers[_k], checkpoint[name][\"optimizer_state\"])\n self.adaptive_load_nets(self.schedulers[_k], checkpoint[name][\"scheduler_state\"])\n self.iter = checkpoint[\"iter\"]\n #self.best_iou = checkpoint['best_iou']\n logger.info(\n \"Loaded checkpoint '{}' (iter {})\".format(\n cfg['training']['resume'], checkpoint[\"iter\"]\n )\n )\n else:\n raise Exception(\"No checkpoint found at '{}'\".format(cfg['training']['resume']))\n\n\n def load_PredNet(self, cfg, writer, logger, dir=None, net=None): # load pretrained weights on the net\n dir = dir or cfg['training']['Pred_resume']\n best_iou = 0\n if os.path.isfile(dir):\n logger.info(\n \"Loading model and optimizer from checkpoint '{}'\".format(dir)\n )\n checkpoint = torch.load(dir)\n name = net.__class__.__name__\n if checkpoint.get(name) == None:\n return\n if name.find('FCDiscriminator') != -1 and cfg['training']['gan_resume'] == False:\n return\n if isinstance(checkpoint[name], list):\n self.adaptive_load_nets(net, checkpoint[name][0][\"model_state\"])\n else:\n self.adaptive_load_nets(net, checkpoint[name][\"model_state\"])\n iter = checkpoint[\"iter\"]\n best_iou = checkpoint['best_iou']\n logger.info(\n \"Loaded checkpoint '{}' (iter {}) (best iou {}) for PredNet\".format(\n dir, checkpoint[\"iter\"], best_iou\n )\n )\n else:\n raise Exception(\"No checkpoint found at '{}'\".format(dir))\n if hasattr(net, 'best_iou'):\n #net.best_iou = best_iou\n pass\n return best_iou\n\n\n def set_optimizer(self, optimizer): #set optimizer to all nets\n pass\n\n def reset_objective_SingleVector(self,):\n self.objective_vectors_group = torch.zeros(self.modal_num + 1, 19, 256).cuda()\n self.objective_vectors_num_group = torch.zeros(self.modal_num + 1, 19).cuda()\n self.objective_vectors_dis_group = torch.zeros(self.modal_num + 1, 19, 19).cuda()\n\n def update_objective_SingleVector(self, vectors, vectors_num, name='moving_average'):\n #vector = vector.squeeze().detach()\n if torch.sum(vectors) == 0:\n return\n if name == 'moving_average':\n self.objective_vectors_group = self.objective_vectors_group * 0.9999 + 0.0001 * vectors\n self.objective_vectors_num_group += vectors_num\n self.objective_vectors_num_group = min(self.objective_vectors_num_group, 3000)\n elif name == 'mean':\n self.objective_vectors_group = self.objective_vectors_group * self.objective_vectors_num_group + vectors\n self.objective_vectors_num_group += vectors_num\n self.objective_vectors_group = self.objective_vectors_group / self.objective_vectors_num_group\n self.objective_vectors_num_group = min(self.objective_vectors_num_group, 3000)\n else:\n raise NotImplementedError('no such updating way of objective vectors {}'.format(name))\n\ndef grad_reverse(x):\n return GradReverse()(x)\n\n"
] | [
[
"torch.cat",
"torch.nn.init.kaiming_normal_",
"numpy.mean",
"torch.nn.SmoothL1Loss",
"torch.cuda.is_available",
"torch.nn.BCEWithLogitsLoss",
"torch.load",
"torch.sum",
"torch.nn.init.constant_",
"torch.nn.functional.adaptive_avg_pool2d",
"torch.nn.init.normal_",
"torch.as_tensor",
"torch.nn.init.orthogonal_",
"torch.nn.init.xavier_normal_",
"torch.Tensor",
"torch.masked_select",
"torch.zeros",
"torch.nn.TripletMarginLoss",
"numpy.zeros",
"torch.cuda.device_count",
"torch.full",
"torch.nn.functional.softmax",
"torch.nn.MSELoss",
"torch.nn.functional.interpolate",
"torch.no_grad",
"torch.nn.L1Loss",
"torch.mean"
]
] |
OSUrobotics/KinovaGrasping | [
"f22af60d3683fdc4ffecf49ccff179fbc6750748"
] | [
"gym-kinova-gripper/plotting_code/other_plots.py"
] | [
"import matplotlib.pyplot as plt\nimport numpy as np\n\n## Extra plotting functions that can be called for quick analysis\n\ndef plot_timestep_distribution(success_timesteps=None, fail_timesteps=None, all_timesteps=None, expert_saving_dir=None):\n \"\"\" Plot the distribution of time steps over successful and failed episodes \"\"\"\n if all_timesteps is None:\n success_timesteps = np.load(expert_saving_dir + \"/success_timesteps.npy\")\n fail_timesteps = np.load(expert_saving_dir + \"/fail_timesteps.npy\")\n all_timesteps = np.load(expert_saving_dir + \"/all_timesteps.npy\")\n\n n_bins = 40\n # We can set the number of bins with the `bins` kwarg\n plt.hist(all_timesteps, bins=n_bins, color=\"g\")\n plt.title(\"Total time steps distribution for all episodes (3x speed)\", weight='bold')\n plt.xlabel('# of time steps per episode')\n plt.ylabel('# of episodes with the time step count')\n plt.xlim(0, 800)\n plt.savefig(expert_saving_dir + \"/total_timestep_distribution\")\n plt.clf()\n\n plt.hist(success_timesteps, bins=n_bins, color=\"b\")\n plt.title(\"Time steps distribution for Successful episodes (3x speed)\", weight='bold')\n plt.xlabel('# of time steps per episode')\n plt.ylabel('# of episodes with the time step count')\n plt.savefig(expert_saving_dir + \"/success_timestep_distribution\")\n plt.clf()\n\n plt.hist(fail_timesteps, bins=n_bins, color=\"r\")\n plt.title(\"Time steps distribution for Failed episodes (3x speed)\", weight='bold')\n plt.xlabel('# of time steps per episode')\n plt.ylabel('# of episodes with the time step count')\n plt.savefig(expert_saving_dir + \"/fail_timestep_distribution\")\n plt.clf()\n\n\n'''\n# Plot the average velocity over an episode\ndef plot_average_velocity(replay_buffer,num_timesteps):\n \"\"\" Plot the average velocity over a certain number of episodes \"\"\"\n velocity_dir = \"./expert_average_velocity\"\n if not os.path.isdir(velocity_dir):\n os.mkdir(velocity_dir)\n\n #num_episodes = len(f1_vels)\n\n #plt.plot(np.arrange(len(f1_vels)), f1_vels)\n\n max_timesteps = 30\n timestep_vel_count = np.zeros(max_timesteps)\n wrist_avg_vels = np.zeros(max_timesteps)\n f1_avg_vels = np.zeros(max_timesteps)\n f2_avg_vels = np.zeros(max_timesteps)\n f3_avg_vels = np.zeros(max_timesteps)\n\n for episode_actions in replay_buffer.action:\n for timestep_idx in range(len(episode_actions)):\n timestep_vel_count[timestep_idx] += 1\n wrist_avg_vels[timestep_idx] = (wrist_avg_vels[timestep_idx] + episode_actions[timestep_idx][0]) / timestep_vel_count[timestep_idx]\n f1_avg_vels[timestep_idx] = (f1_avg_vels[timestep_idx] + episode_actions[timestep_idx][1]) / \\\n timestep_vel_count[timestep_idx]\n f2_avg_vels[timestep_idx] = (f2_avg_vels[timestep_idx] + episode_actions[timestep_idx][2]) / \\\n timestep_vel_count[timestep_idx]\n f3_avg_vels[timestep_idx] = (f3_avg_vels[timestep_idx] + episode_actions[timestep_idx][3]) / \\\n timestep_vel_count[timestep_idx]\n\n num_episodes = len(replay_buffer.action)\n print(\"replay_buffer.action: \",replay_buffer.action)\n print(\"f1_avg_vels: \",f1_avg_vels)\n plt.plot(np.arange(num_timesteps), f1_avg_vels, color=\"r\", label=\"Finger1\")\n plt.plot(np.arange(num_timesteps), f2_avg_vels, color=\"b\", label=\"Finger2\")\n plt.plot(np.arange(num_timesteps), f3_avg_vels, color=\"g\", label=\"Finger3\")\n plt.plot(np.arange(num_timesteps), wrist_avg_vels, color=\"y\", label=\"Wrist\")\n plt.legend()\n\n plt.title(\"Average velocity over \"+str(num_episodes)+\" episodes\", weight='bold')\n plt.xlabel('Timestep within an episode')\n plt.ylabel('Average Velocity at Timestep')\n #plt.savefig(velocity_dir + \"/velocity_plot\")\n #plt.clf()\n plt.show()\n'''"
] | [
[
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.title",
"numpy.load",
"matplotlib.pyplot.hist",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.clf"
]
] |
wenyuC94/LogConcComp | [
"b17d6ba6a102ba83a8415774b0e6da27a362bd5d"
] | [
"src/utils.py"
] | [
"import os\nimport numpy as np\nimport numba as nb\n\ndef create_folder(storage_path):\n if not os.path.isdir(storage_path):\n os.makedirs(storage_path,exist_ok=True)\n lsdir = os.listdir(storage_path)\n for item in [\"info\",\"hist\",\"soln\",\"figs\"]:\n if item not in lsdir:\n os.makedirs(storage_path+item+\"/\",exist_ok=True)\n if item == \"figs\":\n lsdir_figs = os.listdir(storage_path+item+\"/\")\n for item1 in [\"crop\",\"raw\"]:\n if item1 not in lsdir_figs:\n os.makedirs(storage_path+item+\"/\"+item1+\"/\",exist_ok=True)\n \n \ndef time_to_string(runtime):\n seconds = runtime%60\n runmins = (runtime-seconds)/60\n mins = int(runmins%60)\n runhrs = (runmins-mins)/60\n hrs = int(runhrs)\n return \"%.2d:%.2d:%05.2f\"%(hrs,mins,seconds)\n\ndef multivariate_laplace(n,d,rng=None, random_state=None):\n rng = rng if rng is not None else np.random.RandomState(random_state)\n X = rng.randn(n,d)\n Z = rng.exponential(size=(n,1))\n return X*np.sqrt(Z)\n\n\[email protected](cache=True)\ndef np_apply_along_axis(func1d, axis, arr):\n assert arr.ndim == 2\n assert axis in [0, 1]\n if axis == 0:\n result = np.empty(arr.shape[1])\n for i in range(len(result)):\n result[i] = func1d(arr[:, i])\n else:\n result = np.empty(arr.shape[0])\n for i in range(len(result)):\n result[i] = func1d(arr[i, :])\n return result\n\n\[email protected](cache=True)\ndef np_apply_along_axis_kd(funckd, axis, arr, k = -1):\n assert arr.ndim == 2\n assert axis in [0, 1]\n if axis == 0:\n k = k if k > 0 else arr.shape[0]\n result = np.empty((k,arr.shape[1]))\n for i in range(arr.shape[1]):\n result[:, i] = funckd(arr[:, i])\n else:\n k = k if k > 0 else arr.shape[1]\n result = np.empty((arr.shape[0],k))\n for i in range(arr.shape[0]):\n result[i, :] = funckd(arr[i, :])\n return result\n\[email protected](cache=True)\ndef split(n, B):\n sep = n//B\n rem = n%B\n indices = []\n last = 0\n cur = 0\n for i in range(B):\n cur = last + sep + (i < rem)\n indices.append(cur)\n last = cur\n return indices\n\n"
] | [
[
"numpy.empty",
"numpy.sqrt",
"numpy.random.RandomState"
]
] |
1suancaiyu/STEP | [
"54195112990feaee137f5137775c736d07c2d26f"
] | [
"classifier_stgcn_real_only/utils/temp.py"
] | [
"import h5py\nimport os\nimport numpy as np\n\nbase_path = os.path.dirname(os.path.realpath(__file__))\nfeature_file = '/media/uttaran/FCE1-7BF3/Gamma/Gait/classifier_stgcn/model_classifier_stgcn/featuresCombineddeep_features.txt'\nf = np.loadtxt(feature_file)\nfCombined = h5py.File('/media/uttaran/FCE1-7BF3/Gamma/Gait/data/featuresCombined.h5', 'r')\nfkeys = fCombined.keys()\ndfCombined = h5py.File('/media/uttaran/FCE1-7BF3/Gamma/Gait/data/deepFeaturesCombined.h5', 'w')\nfor i, fkey in enumerate(fkeys):\n fname = [fkey][0]\n feature = f[i, :]\n dfCombined.create_dataset(fname, data=feature)\ndfCombined.close()\n"
] | [
[
"numpy.loadtxt"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.